1 // clang-format off 2 // Generated file (from: transpose_conv2d.mod.py). Do not edit 3 std::vector<MixedTypedExample>& get_examples_nhwc_none() { 4 static std::vector<MixedTypedExample> examples_nhwc_none = { 5 // Begin of an example 6 { 7 .operands = { 8 //Input(s) 9 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10 // int -> Dimensions map 11 .operandDimensions = {{0, {1, 2, 2, 1}}}, 12 // int -> FLOAT32 map 13 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.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, 5, 5, 2}}}, 35 // int -> FLOAT32 map 36 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 37 // int -> INT32 map 38 .int32Operands = {}, 39 // int -> QUANT8_ASYMM map 40 .quant8AsymmOperands = {}, 41 // int -> QUANT16_SYMM map 42 .quant16SymmOperands = {}, 43 // int -> FLOAT16 map 44 .float16Operands = {}, 45 // int -> BOOL8 map 46 .bool8Operands = {}, 47 // int -> QUANT8_SYMM_PER_CHANNEL map 48 .quant8ChannelOperands = {}, 49 // int -> QUANT16_ASYMM map 50 .quant16AsymmOperands = {}, 51 // int -> QUANT8_SYMM map 52 .quant8SymmOperands = {}, 53 } 54 }, 55 }, // End of an example 56 }; 57 return examples_nhwc_none; 58 }; 59 60 std::vector<MixedTypedExample>& get_examples_nhwc_none_weight_as_input() { 61 static std::vector<MixedTypedExample> examples_nhwc_none_weight_as_input = { 62 // Begin of an example 63 { 64 .operands = { 65 //Input(s) 66 { // See tools/test_generator/include/TestHarness.h:MixedTyped 67 // int -> Dimensions map 68 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 69 // int -> FLOAT32 map 70 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 71 // int -> INT32 map 72 .int32Operands = {}, 73 // int -> QUANT8_ASYMM map 74 .quant8AsymmOperands = {}, 75 // int -> QUANT16_SYMM map 76 .quant16SymmOperands = {}, 77 // int -> FLOAT16 map 78 .float16Operands = {}, 79 // int -> BOOL8 map 80 .bool8Operands = {}, 81 // int -> QUANT8_SYMM_PER_CHANNEL map 82 .quant8ChannelOperands = {}, 83 // int -> QUANT16_ASYMM map 84 .quant16AsymmOperands = {}, 85 // int -> QUANT8_SYMM map 86 .quant8SymmOperands = {}, 87 }, 88 //Output(s) 89 { // See tools/test_generator/include/TestHarness.h:MixedTyped 90 // int -> Dimensions map 91 .operandDimensions = {{0, {1, 5, 5, 2}}}, 92 // int -> FLOAT32 map 93 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 94 // int -> INT32 map 95 .int32Operands = {}, 96 // int -> QUANT8_ASYMM map 97 .quant8AsymmOperands = {}, 98 // int -> QUANT16_SYMM map 99 .quant16SymmOperands = {}, 100 // int -> FLOAT16 map 101 .float16Operands = {}, 102 // int -> BOOL8 map 103 .bool8Operands = {}, 104 // int -> QUANT8_SYMM_PER_CHANNEL map 105 .quant8ChannelOperands = {}, 106 // int -> QUANT16_ASYMM map 107 .quant16AsymmOperands = {}, 108 // int -> QUANT8_SYMM map 109 .quant8SymmOperands = {}, 110 } 111 }, 112 }, // End of an example 113 }; 114 return examples_nhwc_none_weight_as_input; 115 }; 116 117 std::vector<MixedTypedExample>& get_examples_nhwc_none_relaxed() { 118 static std::vector<MixedTypedExample> examples_nhwc_none_relaxed = { 119 // Begin of an example 120 { 121 .operands = { 122 //Input(s) 123 { // See tools/test_generator/include/TestHarness.h:MixedTyped 124 // int -> Dimensions map 125 .operandDimensions = {{0, {1, 2, 2, 1}}}, 126 // int -> FLOAT32 map 127 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 128 // int -> INT32 map 129 .int32Operands = {}, 130 // int -> QUANT8_ASYMM map 131 .quant8AsymmOperands = {}, 132 // int -> QUANT16_SYMM map 133 .quant16SymmOperands = {}, 134 // int -> FLOAT16 map 135 .float16Operands = {}, 136 // int -> BOOL8 map 137 .bool8Operands = {}, 138 // int -> QUANT8_SYMM_PER_CHANNEL map 139 .quant8ChannelOperands = {}, 140 // int -> QUANT16_ASYMM map 141 .quant16AsymmOperands = {}, 142 // int -> QUANT8_SYMM map 143 .quant8SymmOperands = {}, 144 }, 145 //Output(s) 146 { // See tools/test_generator/include/TestHarness.h:MixedTyped 147 // int -> Dimensions map 148 .operandDimensions = {{0, {1, 5, 5, 2}}}, 149 // int -> FLOAT32 map 150 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 151 // int -> INT32 map 152 .int32Operands = {}, 153 // int -> QUANT8_ASYMM map 154 .quant8AsymmOperands = {}, 155 // int -> QUANT16_SYMM map 156 .quant16SymmOperands = {}, 157 // int -> FLOAT16 map 158 .float16Operands = {}, 159 // int -> BOOL8 map 160 .bool8Operands = {}, 161 // int -> QUANT8_SYMM_PER_CHANNEL map 162 .quant8ChannelOperands = {}, 163 // int -> QUANT16_ASYMM map 164 .quant16AsymmOperands = {}, 165 // int -> QUANT8_SYMM map 166 .quant8SymmOperands = {}, 167 } 168 }, 169 }, // End of an example 170 }; 171 return examples_nhwc_none_relaxed; 172 }; 173 174 std::vector<MixedTypedExample>& get_examples_nhwc_none_relaxed_weight_as_input() { 175 static std::vector<MixedTypedExample> examples_nhwc_none_relaxed_weight_as_input = { 176 // Begin of an example 177 { 178 .operands = { 179 //Input(s) 180 { // See tools/test_generator/include/TestHarness.h:MixedTyped 181 // int -> Dimensions map 182 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 183 // int -> FLOAT32 map 184 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 185 // int -> INT32 map 186 .int32Operands = {}, 187 // int -> QUANT8_ASYMM map 188 .quant8AsymmOperands = {}, 189 // int -> QUANT16_SYMM map 190 .quant16SymmOperands = {}, 191 // int -> FLOAT16 map 192 .float16Operands = {}, 193 // int -> BOOL8 map 194 .bool8Operands = {}, 195 // int -> QUANT8_SYMM_PER_CHANNEL map 196 .quant8ChannelOperands = {}, 197 // int -> QUANT16_ASYMM map 198 .quant16AsymmOperands = {}, 199 // int -> QUANT8_SYMM map 200 .quant8SymmOperands = {}, 201 }, 202 //Output(s) 203 { // See tools/test_generator/include/TestHarness.h:MixedTyped 204 // int -> Dimensions map 205 .operandDimensions = {{0, {1, 5, 5, 2}}}, 206 // int -> FLOAT32 map 207 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 208 // int -> INT32 map 209 .int32Operands = {}, 210 // int -> QUANT8_ASYMM map 211 .quant8AsymmOperands = {}, 212 // int -> QUANT16_SYMM map 213 .quant16SymmOperands = {}, 214 // int -> FLOAT16 map 215 .float16Operands = {}, 216 // int -> BOOL8 map 217 .bool8Operands = {}, 218 // int -> QUANT8_SYMM_PER_CHANNEL map 219 .quant8ChannelOperands = {}, 220 // int -> QUANT16_ASYMM map 221 .quant16AsymmOperands = {}, 222 // int -> QUANT8_SYMM map 223 .quant8SymmOperands = {}, 224 } 225 }, 226 }, // End of an example 227 }; 228 return examples_nhwc_none_relaxed_weight_as_input; 229 }; 230 231 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8() { 232 static std::vector<MixedTypedExample> examples_nhwc_none_quant8 = { 233 // Begin of an example 234 { 235 .operands = { 236 //Input(s) 237 { // See tools/test_generator/include/TestHarness.h:MixedTyped 238 // int -> Dimensions map 239 .operandDimensions = {{0, {1, 2, 2, 1}}}, 240 // int -> FLOAT32 map 241 .float32Operands = {}, 242 // int -> INT32 map 243 .int32Operands = {}, 244 // int -> QUANT8_ASYMM map 245 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 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, 5, 5, 2}}}, 263 // int -> FLOAT32 map 264 .float32Operands = {}, 265 // int -> INT32 map 266 .int32Operands = {}, 267 // int -> QUANT8_ASYMM map 268 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 269 // int -> QUANT16_SYMM map 270 .quant16SymmOperands = {}, 271 // int -> FLOAT16 map 272 .float16Operands = {}, 273 // int -> BOOL8 map 274 .bool8Operands = {}, 275 // int -> QUANT8_SYMM_PER_CHANNEL map 276 .quant8ChannelOperands = {}, 277 // int -> QUANT16_ASYMM map 278 .quant16AsymmOperands = {}, 279 // int -> QUANT8_SYMM map 280 .quant8SymmOperands = {}, 281 } 282 }, 283 }, // End of an example 284 }; 285 return examples_nhwc_none_quant8; 286 }; 287 288 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_weight_as_input() { 289 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_weight_as_input = { 290 // Begin of an example 291 { 292 .operands = { 293 //Input(s) 294 { // See tools/test_generator/include/TestHarness.h:MixedTyped 295 // int -> Dimensions map 296 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 297 // int -> FLOAT32 map 298 .float32Operands = {}, 299 // int -> INT32 map 300 .int32Operands = {{2, {-6, -8}}}, 301 // int -> QUANT8_ASYMM map 302 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 320 // int -> FLOAT32 map 321 .float32Operands = {}, 322 // int -> INT32 map 323 .int32Operands = {}, 324 // int -> QUANT8_ASYMM map 325 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 326 // int -> QUANT16_SYMM map 327 .quant16SymmOperands = {}, 328 // int -> FLOAT16 map 329 .float16Operands = {}, 330 // int -> BOOL8 map 331 .bool8Operands = {}, 332 // int -> QUANT8_SYMM_PER_CHANNEL map 333 .quant8ChannelOperands = {}, 334 // int -> QUANT16_ASYMM map 335 .quant16AsymmOperands = {}, 336 // int -> QUANT8_SYMM map 337 .quant8SymmOperands = {}, 338 } 339 }, 340 }, // End of an example 341 }; 342 return examples_nhwc_none_quant8_weight_as_input; 343 }; 344 345 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_2() { 346 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_2 = { 347 // Begin of an example 348 { 349 .operands = { 350 //Input(s) 351 { // See tools/test_generator/include/TestHarness.h:MixedTyped 352 // int -> Dimensions map 353 .operandDimensions = {{0, {1, 2, 2, 1}}}, 354 // int -> FLOAT32 map 355 .float32Operands = {}, 356 // int -> INT32 map 357 .int32Operands = {}, 358 // int -> QUANT8_ASYMM map 359 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 360 // int -> QUANT16_SYMM map 361 .quant16SymmOperands = {}, 362 // int -> FLOAT16 map 363 .float16Operands = {}, 364 // int -> BOOL8 map 365 .bool8Operands = {}, 366 // int -> QUANT8_SYMM_PER_CHANNEL map 367 .quant8ChannelOperands = {}, 368 // int -> QUANT16_ASYMM map 369 .quant16AsymmOperands = {}, 370 // int -> QUANT8_SYMM map 371 .quant8SymmOperands = {}, 372 }, 373 //Output(s) 374 { // See tools/test_generator/include/TestHarness.h:MixedTyped 375 // int -> Dimensions map 376 .operandDimensions = {{0, {1, 5, 5, 2}}}, 377 // int -> FLOAT32 map 378 .float32Operands = {}, 379 // int -> INT32 map 380 .int32Operands = {}, 381 // int -> QUANT8_ASYMM map 382 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 383 // int -> QUANT16_SYMM map 384 .quant16SymmOperands = {}, 385 // int -> FLOAT16 map 386 .float16Operands = {}, 387 // int -> BOOL8 map 388 .bool8Operands = {}, 389 // int -> QUANT8_SYMM_PER_CHANNEL map 390 .quant8ChannelOperands = {}, 391 // int -> QUANT16_ASYMM map 392 .quant16AsymmOperands = {}, 393 // int -> QUANT8_SYMM map 394 .quant8SymmOperands = {}, 395 } 396 }, 397 }, // End of an example 398 }; 399 return examples_nhwc_none_quant8_2; 400 }; 401 402 std::vector<MixedTypedExample>& get_examples_nhwc_none_quant8_weight_as_input_2() { 403 static std::vector<MixedTypedExample> examples_nhwc_none_quant8_weight_as_input_2 = { 404 // Begin of an example 405 { 406 .operands = { 407 //Input(s) 408 { // See tools/test_generator/include/TestHarness.h:MixedTyped 409 // int -> Dimensions map 410 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 411 // int -> FLOAT32 map 412 .float32Operands = {}, 413 // int -> INT32 map 414 .int32Operands = {{2, {-6, -8}}}, 415 // int -> QUANT8_ASYMM map 416 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5, 2}}}, 434 // int -> FLOAT32 map 435 .float32Operands = {}, 436 // int -> INT32 map 437 .int32Operands = {}, 438 // int -> QUANT8_ASYMM map 439 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 440 // int -> QUANT16_SYMM map 441 .quant16SymmOperands = {}, 442 // int -> FLOAT16 map 443 .float16Operands = {}, 444 // int -> BOOL8 map 445 .bool8Operands = {}, 446 // int -> QUANT8_SYMM_PER_CHANNEL map 447 .quant8ChannelOperands = {}, 448 // int -> QUANT16_ASYMM map 449 .quant16AsymmOperands = {}, 450 // int -> QUANT8_SYMM map 451 .quant8SymmOperands = {}, 452 } 453 }, 454 }, // End of an example 455 }; 456 return examples_nhwc_none_quant8_weight_as_input_2; 457 }; 458 459 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8() { 460 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8 = { 461 // Begin of an example 462 { 463 .operands = { 464 //Input(s) 465 { // See tools/test_generator/include/TestHarness.h:MixedTyped 466 // int -> Dimensions map 467 .operandDimensions = {{0, {1, 2, 2, 1}}}, 468 // int -> FLOAT32 map 469 .float32Operands = {}, 470 // int -> INT32 map 471 .int32Operands = {}, 472 // int -> QUANT8_ASYMM map 473 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 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, 5, 5, 2}}}, 491 // int -> FLOAT32 map 492 .float32Operands = {}, 493 // int -> INT32 map 494 .int32Operands = {}, 495 // int -> QUANT8_ASYMM map 496 .quant8AsymmOperands = {{0, {79, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 497 // int -> QUANT16_SYMM map 498 .quant16SymmOperands = {}, 499 // int -> FLOAT16 map 500 .float16Operands = {}, 501 // int -> BOOL8 map 502 .bool8Operands = {}, 503 // int -> QUANT8_SYMM_PER_CHANNEL map 504 .quant8ChannelOperands = {}, 505 // int -> QUANT16_ASYMM map 506 .quant16AsymmOperands = {}, 507 // int -> QUANT8_SYMM map 508 .quant8SymmOperands = {}, 509 } 510 }, 511 }, // End of an example 512 }; 513 return examples_nhwc_none_channelQuant8; 514 }; 515 516 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_weight_as_input() { 517 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_weight_as_input = { 518 // Begin of an example 519 { 520 .operands = { 521 //Input(s) 522 { // See tools/test_generator/include/TestHarness.h:MixedTyped 523 // int -> Dimensions map 524 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 525 // int -> FLOAT32 map 526 .float32Operands = {}, 527 // int -> INT32 map 528 .int32Operands = {{2, {-24, -16}}}, 529 // int -> QUANT8_ASYMM map 530 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 531 // int -> QUANT16_SYMM map 532 .quant16SymmOperands = {}, 533 // int -> FLOAT16 map 534 .float16Operands = {}, 535 // int -> BOOL8 map 536 .bool8Operands = {}, 537 // int -> QUANT8_SYMM_PER_CHANNEL map 538 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 548 // int -> FLOAT32 map 549 .float32Operands = {}, 550 // int -> INT32 map 551 .int32Operands = {}, 552 // int -> QUANT8_ASYMM map 553 .quant8AsymmOperands = {{0, {79, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 554 // int -> QUANT16_SYMM map 555 .quant16SymmOperands = {}, 556 // int -> FLOAT16 map 557 .float16Operands = {}, 558 // int -> BOOL8 map 559 .bool8Operands = {}, 560 // int -> QUANT8_SYMM_PER_CHANNEL map 561 .quant8ChannelOperands = {}, 562 // int -> QUANT16_ASYMM map 563 .quant16AsymmOperands = {}, 564 // int -> QUANT8_SYMM map 565 .quant8SymmOperands = {}, 566 } 567 }, 568 }, // End of an example 569 }; 570 return examples_nhwc_none_channelQuant8_weight_as_input; 571 }; 572 573 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_2() { 574 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_2 = { 575 // Begin of an example 576 { 577 .operands = { 578 //Input(s) 579 { // See tools/test_generator/include/TestHarness.h:MixedTyped 580 // int -> Dimensions map 581 .operandDimensions = {{0, {1, 2, 2, 1}}}, 582 // int -> FLOAT32 map 583 .float32Operands = {}, 584 // int -> INT32 map 585 .int32Operands = {}, 586 // int -> QUANT8_ASYMM map 587 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 588 // int -> QUANT16_SYMM map 589 .quant16SymmOperands = {}, 590 // int -> FLOAT16 map 591 .float16Operands = {}, 592 // int -> BOOL8 map 593 .bool8Operands = {}, 594 // int -> QUANT8_SYMM_PER_CHANNEL map 595 .quant8ChannelOperands = {}, 596 // int -> QUANT16_ASYMM map 597 .quant16AsymmOperands = {}, 598 // int -> QUANT8_SYMM map 599 .quant8SymmOperands = {}, 600 }, 601 //Output(s) 602 { // See tools/test_generator/include/TestHarness.h:MixedTyped 603 // int -> Dimensions map 604 .operandDimensions = {{0, {1, 5, 5, 2}}}, 605 // int -> FLOAT32 map 606 .float32Operands = {}, 607 // int -> INT32 map 608 .int32Operands = {}, 609 // int -> QUANT8_ASYMM map 610 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 611 // int -> QUANT16_SYMM map 612 .quant16SymmOperands = {}, 613 // int -> FLOAT16 map 614 .float16Operands = {}, 615 // int -> BOOL8 map 616 .bool8Operands = {}, 617 // int -> QUANT8_SYMM_PER_CHANNEL map 618 .quant8ChannelOperands = {}, 619 // int -> QUANT16_ASYMM map 620 .quant16AsymmOperands = {}, 621 // int -> QUANT8_SYMM map 622 .quant8SymmOperands = {}, 623 } 624 }, 625 }, // End of an example 626 }; 627 return examples_nhwc_none_channelQuant8_2; 628 }; 629 630 std::vector<MixedTypedExample>& get_examples_nhwc_none_channelQuant8_weight_as_input_2() { 631 static std::vector<MixedTypedExample> examples_nhwc_none_channelQuant8_weight_as_input_2 = { 632 // Begin of an example 633 { 634 .operands = { 635 //Input(s) 636 { // See tools/test_generator/include/TestHarness.h:MixedTyped 637 // int -> Dimensions map 638 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 639 // int -> FLOAT32 map 640 .float32Operands = {}, 641 // int -> INT32 map 642 .int32Operands = {{2, {-24, -16}}}, 643 // int -> QUANT8_ASYMM map 644 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 645 // int -> QUANT16_SYMM map 646 .quant16SymmOperands = {}, 647 // int -> FLOAT16 map 648 .float16Operands = {}, 649 // int -> BOOL8 map 650 .bool8Operands = {}, 651 // int -> QUANT8_SYMM_PER_CHANNEL map 652 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 662 // int -> FLOAT32 map 663 .float32Operands = {}, 664 // int -> INT32 map 665 .int32Operands = {}, 666 // int -> QUANT8_ASYMM map 667 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 668 // int -> QUANT16_SYMM map 669 .quant16SymmOperands = {}, 670 // int -> FLOAT16 map 671 .float16Operands = {}, 672 // int -> BOOL8 map 673 .bool8Operands = {}, 674 // int -> QUANT8_SYMM_PER_CHANNEL map 675 .quant8ChannelOperands = {}, 676 // int -> QUANT16_ASYMM map 677 .quant16AsymmOperands = {}, 678 // int -> QUANT8_SYMM map 679 .quant8SymmOperands = {}, 680 } 681 }, 682 }, // End of an example 683 }; 684 return examples_nhwc_none_channelQuant8_weight_as_input_2; 685 }; 686 687 std::vector<MixedTypedExample>& get_examples_nhwc_none_float16() { 688 static std::vector<MixedTypedExample> examples_nhwc_none_float16 = { 689 // Begin of an example 690 { 691 .operands = { 692 //Input(s) 693 { // See tools/test_generator/include/TestHarness.h:MixedTyped 694 // int -> Dimensions map 695 .operandDimensions = {{0, {1, 2, 2, 1}}}, 696 // int -> FLOAT32 map 697 .float32Operands = {}, 698 // int -> INT32 map 699 .int32Operands = {}, 700 // int -> QUANT8_ASYMM map 701 .quant8AsymmOperands = {}, 702 // int -> QUANT16_SYMM map 703 .quant16SymmOperands = {}, 704 // int -> FLOAT16 map 705 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 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, 5, 5, 2}}}, 719 // int -> FLOAT32 map 720 .float32Operands = {}, 721 // int -> INT32 map 722 .int32Operands = {}, 723 // int -> QUANT8_ASYMM map 724 .quant8AsymmOperands = {}, 725 // int -> QUANT16_SYMM map 726 .quant16SymmOperands = {}, 727 // int -> FLOAT16 map 728 .float16Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 729 // int -> BOOL8 map 730 .bool8Operands = {}, 731 // int -> QUANT8_SYMM_PER_CHANNEL map 732 .quant8ChannelOperands = {}, 733 // int -> QUANT16_ASYMM map 734 .quant16AsymmOperands = {}, 735 // int -> QUANT8_SYMM map 736 .quant8SymmOperands = {}, 737 } 738 }, 739 }, // End of an example 740 }; 741 return examples_nhwc_none_float16; 742 }; 743 744 std::vector<MixedTypedExample>& get_examples_nhwc_none_float16_weight_as_input() { 745 static std::vector<MixedTypedExample> examples_nhwc_none_float16_weight_as_input = { 746 // Begin of an example 747 { 748 .operands = { 749 //Input(s) 750 { // See tools/test_generator/include/TestHarness.h:MixedTyped 751 // int -> Dimensions map 752 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 753 // int -> FLOAT32 map 754 .float32Operands = {}, 755 // int -> INT32 map 756 .int32Operands = {}, 757 // int -> QUANT8_ASYMM map 758 .quant8AsymmOperands = {}, 759 // int -> QUANT16_SYMM map 760 .quant16SymmOperands = {}, 761 // int -> FLOAT16 map 762 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 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, 5, 5, 2}}}, 776 // int -> FLOAT32 map 777 .float32Operands = {}, 778 // int -> INT32 map 779 .int32Operands = {}, 780 // int -> QUANT8_ASYMM map 781 .quant8AsymmOperands = {}, 782 // int -> QUANT16_SYMM map 783 .quant16SymmOperands = {}, 784 // int -> FLOAT16 map 785 .float16Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 786 // int -> BOOL8 map 787 .bool8Operands = {}, 788 // int -> QUANT8_SYMM_PER_CHANNEL map 789 .quant8ChannelOperands = {}, 790 // int -> QUANT16_ASYMM map 791 .quant16AsymmOperands = {}, 792 // int -> QUANT8_SYMM map 793 .quant8SymmOperands = {}, 794 } 795 }, 796 }, // End of an example 797 }; 798 return examples_nhwc_none_float16_weight_as_input; 799 }; 800 801 std::vector<MixedTypedExample>& get_examples_nhwc_relu() { 802 static std::vector<MixedTypedExample> examples_nhwc_relu = { 803 // Begin of an example 804 { 805 .operands = { 806 //Input(s) 807 { // See tools/test_generator/include/TestHarness.h:MixedTyped 808 // int -> Dimensions map 809 .operandDimensions = {{0, {1, 2, 2, 1}}}, 810 // int -> FLOAT32 map 811 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 812 // int -> INT32 map 813 .int32Operands = {}, 814 // int -> QUANT8_ASYMM map 815 .quant8AsymmOperands = {}, 816 // int -> QUANT16_SYMM map 817 .quant16SymmOperands = {}, 818 // int -> FLOAT16 map 819 .float16Operands = {}, 820 // int -> BOOL8 map 821 .bool8Operands = {}, 822 // int -> QUANT8_SYMM_PER_CHANNEL map 823 .quant8ChannelOperands = {}, 824 // int -> QUANT16_ASYMM map 825 .quant16AsymmOperands = {}, 826 // int -> QUANT8_SYMM map 827 .quant8SymmOperands = {}, 828 }, 829 //Output(s) 830 { // See tools/test_generator/include/TestHarness.h:MixedTyped 831 // int -> Dimensions map 832 .operandDimensions = {{0, {1, 5, 5, 2}}}, 833 // int -> FLOAT32 map 834 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 835 // int -> INT32 map 836 .int32Operands = {}, 837 // int -> QUANT8_ASYMM map 838 .quant8AsymmOperands = {}, 839 // int -> QUANT16_SYMM map 840 .quant16SymmOperands = {}, 841 // int -> FLOAT16 map 842 .float16Operands = {}, 843 // int -> BOOL8 map 844 .bool8Operands = {}, 845 // int -> QUANT8_SYMM_PER_CHANNEL map 846 .quant8ChannelOperands = {}, 847 // int -> QUANT16_ASYMM map 848 .quant16AsymmOperands = {}, 849 // int -> QUANT8_SYMM map 850 .quant8SymmOperands = {}, 851 } 852 }, 853 }, // End of an example 854 }; 855 return examples_nhwc_relu; 856 }; 857 858 std::vector<MixedTypedExample>& get_examples_nhwc_relu_weight_as_input() { 859 static std::vector<MixedTypedExample> examples_nhwc_relu_weight_as_input = { 860 // Begin of an example 861 { 862 .operands = { 863 //Input(s) 864 { // See tools/test_generator/include/TestHarness.h:MixedTyped 865 // int -> Dimensions map 866 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 867 // int -> FLOAT32 map 868 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 869 // int -> INT32 map 870 .int32Operands = {}, 871 // int -> QUANT8_ASYMM map 872 .quant8AsymmOperands = {}, 873 // int -> QUANT16_SYMM map 874 .quant16SymmOperands = {}, 875 // int -> FLOAT16 map 876 .float16Operands = {}, 877 // int -> BOOL8 map 878 .bool8Operands = {}, 879 // int -> QUANT8_SYMM_PER_CHANNEL map 880 .quant8ChannelOperands = {}, 881 // int -> QUANT16_ASYMM map 882 .quant16AsymmOperands = {}, 883 // int -> QUANT8_SYMM map 884 .quant8SymmOperands = {}, 885 }, 886 //Output(s) 887 { // See tools/test_generator/include/TestHarness.h:MixedTyped 888 // int -> Dimensions map 889 .operandDimensions = {{0, {1, 5, 5, 2}}}, 890 // int -> FLOAT32 map 891 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 892 // int -> INT32 map 893 .int32Operands = {}, 894 // int -> QUANT8_ASYMM map 895 .quant8AsymmOperands = {}, 896 // int -> QUANT16_SYMM map 897 .quant16SymmOperands = {}, 898 // int -> FLOAT16 map 899 .float16Operands = {}, 900 // int -> BOOL8 map 901 .bool8Operands = {}, 902 // int -> QUANT8_SYMM_PER_CHANNEL map 903 .quant8ChannelOperands = {}, 904 // int -> QUANT16_ASYMM map 905 .quant16AsymmOperands = {}, 906 // int -> QUANT8_SYMM map 907 .quant8SymmOperands = {}, 908 } 909 }, 910 }, // End of an example 911 }; 912 return examples_nhwc_relu_weight_as_input; 913 }; 914 915 std::vector<MixedTypedExample>& get_examples_nhwc_relu_relaxed() { 916 static std::vector<MixedTypedExample> examples_nhwc_relu_relaxed = { 917 // Begin of an example 918 { 919 .operands = { 920 //Input(s) 921 { // See tools/test_generator/include/TestHarness.h:MixedTyped 922 // int -> Dimensions map 923 .operandDimensions = {{0, {1, 2, 2, 1}}}, 924 // int -> FLOAT32 map 925 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.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, 5, 5, 2}}}, 947 // int -> FLOAT32 map 948 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 949 // int -> INT32 map 950 .int32Operands = {}, 951 // int -> QUANT8_ASYMM map 952 .quant8AsymmOperands = {}, 953 // int -> QUANT16_SYMM map 954 .quant16SymmOperands = {}, 955 // int -> FLOAT16 map 956 .float16Operands = {}, 957 // int -> BOOL8 map 958 .bool8Operands = {}, 959 // int -> QUANT8_SYMM_PER_CHANNEL map 960 .quant8ChannelOperands = {}, 961 // int -> QUANT16_ASYMM map 962 .quant16AsymmOperands = {}, 963 // int -> QUANT8_SYMM map 964 .quant8SymmOperands = {}, 965 } 966 }, 967 }, // End of an example 968 }; 969 return examples_nhwc_relu_relaxed; 970 }; 971 972 std::vector<MixedTypedExample>& get_examples_nhwc_relu_relaxed_weight_as_input() { 973 static std::vector<MixedTypedExample> examples_nhwc_relu_relaxed_weight_as_input = { 974 // Begin of an example 975 { 976 .operands = { 977 //Input(s) 978 { // See tools/test_generator/include/TestHarness.h:MixedTyped 979 // int -> Dimensions map 980 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 981 // int -> FLOAT32 map 982 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 983 // int -> INT32 map 984 .int32Operands = {}, 985 // int -> QUANT8_ASYMM map 986 .quant8AsymmOperands = {}, 987 // int -> QUANT16_SYMM map 988 .quant16SymmOperands = {}, 989 // int -> FLOAT16 map 990 .float16Operands = {}, 991 // int -> BOOL8 map 992 .bool8Operands = {}, 993 // int -> QUANT8_SYMM_PER_CHANNEL map 994 .quant8ChannelOperands = {}, 995 // int -> QUANT16_ASYMM map 996 .quant16AsymmOperands = {}, 997 // int -> QUANT8_SYMM map 998 .quant8SymmOperands = {}, 999 }, 1000 //Output(s) 1001 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1002 // int -> Dimensions map 1003 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1004 // int -> FLOAT32 map 1005 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 1006 // int -> INT32 map 1007 .int32Operands = {}, 1008 // int -> QUANT8_ASYMM map 1009 .quant8AsymmOperands = {}, 1010 // int -> QUANT16_SYMM map 1011 .quant16SymmOperands = {}, 1012 // int -> FLOAT16 map 1013 .float16Operands = {}, 1014 // int -> BOOL8 map 1015 .bool8Operands = {}, 1016 // int -> QUANT8_SYMM_PER_CHANNEL map 1017 .quant8ChannelOperands = {}, 1018 // int -> QUANT16_ASYMM map 1019 .quant16AsymmOperands = {}, 1020 // int -> QUANT8_SYMM map 1021 .quant8SymmOperands = {}, 1022 } 1023 }, 1024 }, // End of an example 1025 }; 1026 return examples_nhwc_relu_relaxed_weight_as_input; 1027 }; 1028 1029 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8() { 1030 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8 = { 1031 // Begin of an example 1032 { 1033 .operands = { 1034 //Input(s) 1035 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1036 // int -> Dimensions map 1037 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1038 // int -> FLOAT32 map 1039 .float32Operands = {}, 1040 // int -> INT32 map 1041 .int32Operands = {}, 1042 // int -> QUANT8_ASYMM map 1043 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 1044 // int -> QUANT16_SYMM map 1045 .quant16SymmOperands = {}, 1046 // int -> FLOAT16 map 1047 .float16Operands = {}, 1048 // int -> BOOL8 map 1049 .bool8Operands = {}, 1050 // int -> QUANT8_SYMM_PER_CHANNEL map 1051 .quant8ChannelOperands = {}, 1052 // int -> QUANT16_ASYMM map 1053 .quant16AsymmOperands = {}, 1054 // int -> QUANT8_SYMM map 1055 .quant8SymmOperands = {}, 1056 }, 1057 //Output(s) 1058 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1059 // int -> Dimensions map 1060 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1061 // int -> FLOAT32 map 1062 .float32Operands = {}, 1063 // int -> INT32 map 1064 .int32Operands = {}, 1065 // int -> QUANT8_ASYMM map 1066 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 1067 // int -> QUANT16_SYMM map 1068 .quant16SymmOperands = {}, 1069 // int -> FLOAT16 map 1070 .float16Operands = {}, 1071 // int -> BOOL8 map 1072 .bool8Operands = {}, 1073 // int -> QUANT8_SYMM_PER_CHANNEL map 1074 .quant8ChannelOperands = {}, 1075 // int -> QUANT16_ASYMM map 1076 .quant16AsymmOperands = {}, 1077 // int -> QUANT8_SYMM map 1078 .quant8SymmOperands = {}, 1079 } 1080 }, 1081 }, // End of an example 1082 }; 1083 return examples_nhwc_relu_quant8; 1084 }; 1085 1086 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_weight_as_input() { 1087 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_weight_as_input = { 1088 // Begin of an example 1089 { 1090 .operands = { 1091 //Input(s) 1092 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1093 // int -> Dimensions map 1094 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1095 // int -> FLOAT32 map 1096 .float32Operands = {}, 1097 // int -> INT32 map 1098 .int32Operands = {{2, {-6, -8}}}, 1099 // int -> QUANT8_ASYMM map 1100 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 1118 // int -> FLOAT32 map 1119 .float32Operands = {}, 1120 // int -> INT32 map 1121 .int32Operands = {}, 1122 // int -> QUANT8_ASYMM map 1123 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 1124 // int -> QUANT16_SYMM map 1125 .quant16SymmOperands = {}, 1126 // int -> FLOAT16 map 1127 .float16Operands = {}, 1128 // int -> BOOL8 map 1129 .bool8Operands = {}, 1130 // int -> QUANT8_SYMM_PER_CHANNEL map 1131 .quant8ChannelOperands = {}, 1132 // int -> QUANT16_ASYMM map 1133 .quant16AsymmOperands = {}, 1134 // int -> QUANT8_SYMM map 1135 .quant8SymmOperands = {}, 1136 } 1137 }, 1138 }, // End of an example 1139 }; 1140 return examples_nhwc_relu_quant8_weight_as_input; 1141 }; 1142 1143 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_2() { 1144 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_2 = { 1145 // Begin of an example 1146 { 1147 .operands = { 1148 //Input(s) 1149 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1150 // int -> Dimensions map 1151 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1152 // int -> FLOAT32 map 1153 .float32Operands = {}, 1154 // int -> INT32 map 1155 .int32Operands = {}, 1156 // int -> QUANT8_ASYMM map 1157 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 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, 5, 5, 2}}}, 1175 // int -> FLOAT32 map 1176 .float32Operands = {}, 1177 // int -> INT32 map 1178 .int32Operands = {}, 1179 // int -> QUANT8_ASYMM map 1180 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 1181 // int -> QUANT16_SYMM map 1182 .quant16SymmOperands = {}, 1183 // int -> FLOAT16 map 1184 .float16Operands = {}, 1185 // int -> BOOL8 map 1186 .bool8Operands = {}, 1187 // int -> QUANT8_SYMM_PER_CHANNEL map 1188 .quant8ChannelOperands = {}, 1189 // int -> QUANT16_ASYMM map 1190 .quant16AsymmOperands = {}, 1191 // int -> QUANT8_SYMM map 1192 .quant8SymmOperands = {}, 1193 } 1194 }, 1195 }, // End of an example 1196 }; 1197 return examples_nhwc_relu_quant8_2; 1198 }; 1199 1200 std::vector<MixedTypedExample>& get_examples_nhwc_relu_quant8_weight_as_input_2() { 1201 static std::vector<MixedTypedExample> examples_nhwc_relu_quant8_weight_as_input_2 = { 1202 // Begin of an example 1203 { 1204 .operands = { 1205 //Input(s) 1206 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1207 // int -> Dimensions map 1208 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1209 // int -> FLOAT32 map 1210 .float32Operands = {}, 1211 // int -> INT32 map 1212 .int32Operands = {{2, {-6, -8}}}, 1213 // int -> QUANT8_ASYMM map 1214 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5, 2}}}, 1232 // int -> FLOAT32 map 1233 .float32Operands = {}, 1234 // int -> INT32 map 1235 .int32Operands = {}, 1236 // int -> QUANT8_ASYMM map 1237 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 1238 // int -> QUANT16_SYMM map 1239 .quant16SymmOperands = {}, 1240 // int -> FLOAT16 map 1241 .float16Operands = {}, 1242 // int -> BOOL8 map 1243 .bool8Operands = {}, 1244 // int -> QUANT8_SYMM_PER_CHANNEL map 1245 .quant8ChannelOperands = {}, 1246 // int -> QUANT16_ASYMM map 1247 .quant16AsymmOperands = {}, 1248 // int -> QUANT8_SYMM map 1249 .quant8SymmOperands = {}, 1250 } 1251 }, 1252 }, // End of an example 1253 }; 1254 return examples_nhwc_relu_quant8_weight_as_input_2; 1255 }; 1256 1257 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8() { 1258 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8 = { 1259 // Begin of an example 1260 { 1261 .operands = { 1262 //Input(s) 1263 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1264 // int -> Dimensions map 1265 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1266 // int -> FLOAT32 map 1267 .float32Operands = {}, 1268 // int -> INT32 map 1269 .int32Operands = {}, 1270 // int -> QUANT8_ASYMM map 1271 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 1272 // int -> QUANT16_SYMM map 1273 .quant16SymmOperands = {}, 1274 // int -> FLOAT16 map 1275 .float16Operands = {}, 1276 // int -> BOOL8 map 1277 .bool8Operands = {}, 1278 // int -> QUANT8_SYMM_PER_CHANNEL map 1279 .quant8ChannelOperands = {}, 1280 // int -> QUANT16_ASYMM map 1281 .quant16AsymmOperands = {}, 1282 // int -> QUANT8_SYMM map 1283 .quant8SymmOperands = {}, 1284 }, 1285 //Output(s) 1286 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1287 // int -> Dimensions map 1288 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1289 // int -> FLOAT32 map 1290 .float32Operands = {}, 1291 // int -> INT32 map 1292 .int32Operands = {}, 1293 // int -> QUANT8_ASYMM map 1294 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 1295 // int -> QUANT16_SYMM map 1296 .quant16SymmOperands = {}, 1297 // int -> FLOAT16 map 1298 .float16Operands = {}, 1299 // int -> BOOL8 map 1300 .bool8Operands = {}, 1301 // int -> QUANT8_SYMM_PER_CHANNEL map 1302 .quant8ChannelOperands = {}, 1303 // int -> QUANT16_ASYMM map 1304 .quant16AsymmOperands = {}, 1305 // int -> QUANT8_SYMM map 1306 .quant8SymmOperands = {}, 1307 } 1308 }, 1309 }, // End of an example 1310 }; 1311 return examples_nhwc_relu_channelQuant8; 1312 }; 1313 1314 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_weight_as_input() { 1315 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_weight_as_input = { 1316 // Begin of an example 1317 { 1318 .operands = { 1319 //Input(s) 1320 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1321 // int -> Dimensions map 1322 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1323 // int -> FLOAT32 map 1324 .float32Operands = {}, 1325 // int -> INT32 map 1326 .int32Operands = {{2, {-24, -16}}}, 1327 // int -> QUANT8_ASYMM map 1328 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 1329 // int -> QUANT16_SYMM map 1330 .quant16SymmOperands = {}, 1331 // int -> FLOAT16 map 1332 .float16Operands = {}, 1333 // int -> BOOL8 map 1334 .bool8Operands = {}, 1335 // int -> QUANT8_SYMM_PER_CHANNEL map 1336 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 1346 // int -> FLOAT32 map 1347 .float32Operands = {}, 1348 // int -> INT32 map 1349 .int32Operands = {}, 1350 // int -> QUANT8_ASYMM map 1351 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 1352 // int -> QUANT16_SYMM map 1353 .quant16SymmOperands = {}, 1354 // int -> FLOAT16 map 1355 .float16Operands = {}, 1356 // int -> BOOL8 map 1357 .bool8Operands = {}, 1358 // int -> QUANT8_SYMM_PER_CHANNEL map 1359 .quant8ChannelOperands = {}, 1360 // int -> QUANT16_ASYMM map 1361 .quant16AsymmOperands = {}, 1362 // int -> QUANT8_SYMM map 1363 .quant8SymmOperands = {}, 1364 } 1365 }, 1366 }, // End of an example 1367 }; 1368 return examples_nhwc_relu_channelQuant8_weight_as_input; 1369 }; 1370 1371 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_2() { 1372 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_2 = { 1373 // Begin of an example 1374 { 1375 .operands = { 1376 //Input(s) 1377 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1378 // int -> Dimensions map 1379 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1380 // int -> FLOAT32 map 1381 .float32Operands = {}, 1382 // int -> INT32 map 1383 .int32Operands = {}, 1384 // int -> QUANT8_ASYMM map 1385 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 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, 5, 5, 2}}}, 1403 // int -> FLOAT32 map 1404 .float32Operands = {}, 1405 // int -> INT32 map 1406 .int32Operands = {}, 1407 // int -> QUANT8_ASYMM map 1408 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 1409 // int -> QUANT16_SYMM map 1410 .quant16SymmOperands = {}, 1411 // int -> FLOAT16 map 1412 .float16Operands = {}, 1413 // int -> BOOL8 map 1414 .bool8Operands = {}, 1415 // int -> QUANT8_SYMM_PER_CHANNEL map 1416 .quant8ChannelOperands = {}, 1417 // int -> QUANT16_ASYMM map 1418 .quant16AsymmOperands = {}, 1419 // int -> QUANT8_SYMM map 1420 .quant8SymmOperands = {}, 1421 } 1422 }, 1423 }, // End of an example 1424 }; 1425 return examples_nhwc_relu_channelQuant8_2; 1426 }; 1427 1428 std::vector<MixedTypedExample>& get_examples_nhwc_relu_channelQuant8_weight_as_input_2() { 1429 static std::vector<MixedTypedExample> examples_nhwc_relu_channelQuant8_weight_as_input_2 = { 1430 // Begin of an example 1431 { 1432 .operands = { 1433 //Input(s) 1434 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1435 // int -> Dimensions map 1436 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1437 // int -> FLOAT32 map 1438 .float32Operands = {}, 1439 // int -> INT32 map 1440 .int32Operands = {{2, {-24, -16}}}, 1441 // int -> QUANT8_ASYMM map 1442 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 1443 // int -> QUANT16_SYMM map 1444 .quant16SymmOperands = {}, 1445 // int -> FLOAT16 map 1446 .float16Operands = {}, 1447 // int -> BOOL8 map 1448 .bool8Operands = {}, 1449 // int -> QUANT8_SYMM_PER_CHANNEL map 1450 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 1460 // int -> FLOAT32 map 1461 .float32Operands = {}, 1462 // int -> INT32 map 1463 .int32Operands = {}, 1464 // int -> QUANT8_ASYMM map 1465 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 1466 // int -> QUANT16_SYMM map 1467 .quant16SymmOperands = {}, 1468 // int -> FLOAT16 map 1469 .float16Operands = {}, 1470 // int -> BOOL8 map 1471 .bool8Operands = {}, 1472 // int -> QUANT8_SYMM_PER_CHANNEL map 1473 .quant8ChannelOperands = {}, 1474 // int -> QUANT16_ASYMM map 1475 .quant16AsymmOperands = {}, 1476 // int -> QUANT8_SYMM map 1477 .quant8SymmOperands = {}, 1478 } 1479 }, 1480 }, // End of an example 1481 }; 1482 return examples_nhwc_relu_channelQuant8_weight_as_input_2; 1483 }; 1484 1485 std::vector<MixedTypedExample>& get_examples_nhwc_relu_float16() { 1486 static std::vector<MixedTypedExample> examples_nhwc_relu_float16 = { 1487 // Begin of an example 1488 { 1489 .operands = { 1490 //Input(s) 1491 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1492 // int -> Dimensions map 1493 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1494 // int -> FLOAT32 map 1495 .float32Operands = {}, 1496 // int -> INT32 map 1497 .int32Operands = {}, 1498 // int -> QUANT8_ASYMM map 1499 .quant8AsymmOperands = {}, 1500 // int -> QUANT16_SYMM map 1501 .quant16SymmOperands = {}, 1502 // int -> FLOAT16 map 1503 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.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, 5, 5, 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, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 1527 // int -> BOOL8 map 1528 .bool8Operands = {}, 1529 // int -> QUANT8_SYMM_PER_CHANNEL map 1530 .quant8ChannelOperands = {}, 1531 // int -> QUANT16_ASYMM map 1532 .quant16AsymmOperands = {}, 1533 // int -> QUANT8_SYMM map 1534 .quant8SymmOperands = {}, 1535 } 1536 }, 1537 }, // End of an example 1538 }; 1539 return examples_nhwc_relu_float16; 1540 }; 1541 1542 std::vector<MixedTypedExample>& get_examples_nhwc_relu_float16_weight_as_input() { 1543 static std::vector<MixedTypedExample> examples_nhwc_relu_float16_weight_as_input = { 1544 // Begin of an example 1545 { 1546 .operands = { 1547 //Input(s) 1548 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1549 // int -> Dimensions map 1550 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1551 // int -> FLOAT32 map 1552 .float32Operands = {}, 1553 // int -> INT32 map 1554 .int32Operands = {}, 1555 // int -> QUANT8_ASYMM map 1556 .quant8AsymmOperands = {}, 1557 // int -> QUANT16_SYMM map 1558 .quant16SymmOperands = {}, 1559 // int -> FLOAT16 map 1560 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 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, 5, 5, 2}}}, 1574 // int -> FLOAT32 map 1575 .float32Operands = {}, 1576 // int -> INT32 map 1577 .int32Operands = {}, 1578 // int -> QUANT8_ASYMM map 1579 .quant8AsymmOperands = {}, 1580 // int -> QUANT16_SYMM map 1581 .quant16SymmOperands = {}, 1582 // int -> FLOAT16 map 1583 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 1584 // int -> BOOL8 map 1585 .bool8Operands = {}, 1586 // int -> QUANT8_SYMM_PER_CHANNEL map 1587 .quant8ChannelOperands = {}, 1588 // int -> QUANT16_ASYMM map 1589 .quant16AsymmOperands = {}, 1590 // int -> QUANT8_SYMM map 1591 .quant8SymmOperands = {}, 1592 } 1593 }, 1594 }, // End of an example 1595 }; 1596 return examples_nhwc_relu_float16_weight_as_input; 1597 }; 1598 1599 std::vector<MixedTypedExample>& get_examples_nhwc_relu1() { 1600 static std::vector<MixedTypedExample> examples_nhwc_relu1 = { 1601 // Begin of an example 1602 { 1603 .operands = { 1604 //Input(s) 1605 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1606 // int -> Dimensions map 1607 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1608 // int -> FLOAT32 map 1609 .float32Operands = {{0, {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, 5, 5, 2}}}, 1631 // int -> FLOAT32 map 1632 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 1633 // int -> INT32 map 1634 .int32Operands = {}, 1635 // int -> QUANT8_ASYMM map 1636 .quant8AsymmOperands = {}, 1637 // int -> QUANT16_SYMM map 1638 .quant16SymmOperands = {}, 1639 // int -> FLOAT16 map 1640 .float16Operands = {}, 1641 // int -> BOOL8 map 1642 .bool8Operands = {}, 1643 // int -> QUANT8_SYMM_PER_CHANNEL map 1644 .quant8ChannelOperands = {}, 1645 // int -> QUANT16_ASYMM map 1646 .quant16AsymmOperands = {}, 1647 // int -> QUANT8_SYMM map 1648 .quant8SymmOperands = {}, 1649 } 1650 }, 1651 }, // End of an example 1652 }; 1653 return examples_nhwc_relu1; 1654 }; 1655 1656 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_weight_as_input() { 1657 static std::vector<MixedTypedExample> examples_nhwc_relu1_weight_as_input = { 1658 // Begin of an example 1659 { 1660 .operands = { 1661 //Input(s) 1662 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1663 // int -> Dimensions map 1664 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1665 // int -> FLOAT32 map 1666 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 1667 // int -> INT32 map 1668 .int32Operands = {}, 1669 // int -> QUANT8_ASYMM map 1670 .quant8AsymmOperands = {}, 1671 // int -> QUANT16_SYMM map 1672 .quant16SymmOperands = {}, 1673 // int -> FLOAT16 map 1674 .float16Operands = {}, 1675 // int -> BOOL8 map 1676 .bool8Operands = {}, 1677 // int -> QUANT8_SYMM_PER_CHANNEL map 1678 .quant8ChannelOperands = {}, 1679 // int -> QUANT16_ASYMM map 1680 .quant16AsymmOperands = {}, 1681 // int -> QUANT8_SYMM map 1682 .quant8SymmOperands = {}, 1683 }, 1684 //Output(s) 1685 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1686 // int -> Dimensions map 1687 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1688 // int -> FLOAT32 map 1689 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 1690 // int -> INT32 map 1691 .int32Operands = {}, 1692 // int -> QUANT8_ASYMM map 1693 .quant8AsymmOperands = {}, 1694 // int -> QUANT16_SYMM map 1695 .quant16SymmOperands = {}, 1696 // int -> FLOAT16 map 1697 .float16Operands = {}, 1698 // int -> BOOL8 map 1699 .bool8Operands = {}, 1700 // int -> QUANT8_SYMM_PER_CHANNEL map 1701 .quant8ChannelOperands = {}, 1702 // int -> QUANT16_ASYMM map 1703 .quant16AsymmOperands = {}, 1704 // int -> QUANT8_SYMM map 1705 .quant8SymmOperands = {}, 1706 } 1707 }, 1708 }, // End of an example 1709 }; 1710 return examples_nhwc_relu1_weight_as_input; 1711 }; 1712 1713 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_relaxed() { 1714 static std::vector<MixedTypedExample> examples_nhwc_relu1_relaxed = { 1715 // Begin of an example 1716 { 1717 .operands = { 1718 //Input(s) 1719 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1720 // int -> Dimensions map 1721 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1722 // int -> FLOAT32 map 1723 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 1724 // int -> INT32 map 1725 .int32Operands = {}, 1726 // int -> QUANT8_ASYMM map 1727 .quant8AsymmOperands = {}, 1728 // int -> QUANT16_SYMM map 1729 .quant16SymmOperands = {}, 1730 // int -> FLOAT16 map 1731 .float16Operands = {}, 1732 // int -> BOOL8 map 1733 .bool8Operands = {}, 1734 // int -> QUANT8_SYMM_PER_CHANNEL map 1735 .quant8ChannelOperands = {}, 1736 // int -> QUANT16_ASYMM map 1737 .quant16AsymmOperands = {}, 1738 // int -> QUANT8_SYMM map 1739 .quant8SymmOperands = {}, 1740 }, 1741 //Output(s) 1742 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1743 // int -> Dimensions map 1744 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1745 // int -> FLOAT32 map 1746 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 1747 // int -> INT32 map 1748 .int32Operands = {}, 1749 // int -> QUANT8_ASYMM map 1750 .quant8AsymmOperands = {}, 1751 // int -> QUANT16_SYMM map 1752 .quant16SymmOperands = {}, 1753 // int -> FLOAT16 map 1754 .float16Operands = {}, 1755 // int -> BOOL8 map 1756 .bool8Operands = {}, 1757 // int -> QUANT8_SYMM_PER_CHANNEL map 1758 .quant8ChannelOperands = {}, 1759 // int -> QUANT16_ASYMM map 1760 .quant16AsymmOperands = {}, 1761 // int -> QUANT8_SYMM map 1762 .quant8SymmOperands = {}, 1763 } 1764 }, 1765 }, // End of an example 1766 }; 1767 return examples_nhwc_relu1_relaxed; 1768 }; 1769 1770 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_relaxed_weight_as_input() { 1771 static std::vector<MixedTypedExample> examples_nhwc_relu1_relaxed_weight_as_input = { 1772 // Begin of an example 1773 { 1774 .operands = { 1775 //Input(s) 1776 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1777 // int -> Dimensions map 1778 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1779 // int -> FLOAT32 map 1780 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 1781 // int -> INT32 map 1782 .int32Operands = {}, 1783 // int -> QUANT8_ASYMM map 1784 .quant8AsymmOperands = {}, 1785 // int -> QUANT16_SYMM map 1786 .quant16SymmOperands = {}, 1787 // int -> FLOAT16 map 1788 .float16Operands = {}, 1789 // int -> BOOL8 map 1790 .bool8Operands = {}, 1791 // int -> QUANT8_SYMM_PER_CHANNEL map 1792 .quant8ChannelOperands = {}, 1793 // int -> QUANT16_ASYMM map 1794 .quant16AsymmOperands = {}, 1795 // int -> QUANT8_SYMM map 1796 .quant8SymmOperands = {}, 1797 }, 1798 //Output(s) 1799 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1800 // int -> Dimensions map 1801 .operandDimensions = {{0, {1, 5, 5, 2}}}, 1802 // int -> FLOAT32 map 1803 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 1804 // int -> INT32 map 1805 .int32Operands = {}, 1806 // int -> QUANT8_ASYMM map 1807 .quant8AsymmOperands = {}, 1808 // int -> QUANT16_SYMM map 1809 .quant16SymmOperands = {}, 1810 // int -> FLOAT16 map 1811 .float16Operands = {}, 1812 // int -> BOOL8 map 1813 .bool8Operands = {}, 1814 // int -> QUANT8_SYMM_PER_CHANNEL map 1815 .quant8ChannelOperands = {}, 1816 // int -> QUANT16_ASYMM map 1817 .quant16AsymmOperands = {}, 1818 // int -> QUANT8_SYMM map 1819 .quant8SymmOperands = {}, 1820 } 1821 }, 1822 }, // End of an example 1823 }; 1824 return examples_nhwc_relu1_relaxed_weight_as_input; 1825 }; 1826 1827 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8() { 1828 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8 = { 1829 // Begin of an example 1830 { 1831 .operands = { 1832 //Input(s) 1833 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1834 // int -> Dimensions map 1835 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1836 // int -> FLOAT32 map 1837 .float32Operands = {}, 1838 // int -> INT32 map 1839 .int32Operands = {}, 1840 // int -> QUANT8_ASYMM map 1841 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 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, 5, 5, 2}}}, 1859 // int -> FLOAT32 map 1860 .float32Operands = {}, 1861 // int -> INT32 map 1862 .int32Operands = {}, 1863 // int -> QUANT8_ASYMM map 1864 .quant8AsymmOperands = {{0, {0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 1865 // int -> QUANT16_SYMM map 1866 .quant16SymmOperands = {}, 1867 // int -> FLOAT16 map 1868 .float16Operands = {}, 1869 // int -> BOOL8 map 1870 .bool8Operands = {}, 1871 // int -> QUANT8_SYMM_PER_CHANNEL map 1872 .quant8ChannelOperands = {}, 1873 // int -> QUANT16_ASYMM map 1874 .quant16AsymmOperands = {}, 1875 // int -> QUANT8_SYMM map 1876 .quant8SymmOperands = {}, 1877 } 1878 }, 1879 }, // End of an example 1880 }; 1881 return examples_nhwc_relu1_quant8; 1882 }; 1883 1884 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_weight_as_input() { 1885 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_weight_as_input = { 1886 // Begin of an example 1887 { 1888 .operands = { 1889 //Input(s) 1890 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1891 // int -> Dimensions map 1892 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 1893 // int -> FLOAT32 map 1894 .float32Operands = {}, 1895 // int -> INT32 map 1896 .int32Operands = {{2, {-6, -8}}}, 1897 // int -> QUANT8_ASYMM map 1898 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 1916 // int -> FLOAT32 map 1917 .float32Operands = {}, 1918 // int -> INT32 map 1919 .int32Operands = {}, 1920 // int -> QUANT8_ASYMM map 1921 .quant8AsymmOperands = {{0, {0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 1922 // int -> QUANT16_SYMM map 1923 .quant16SymmOperands = {}, 1924 // int -> FLOAT16 map 1925 .float16Operands = {}, 1926 // int -> BOOL8 map 1927 .bool8Operands = {}, 1928 // int -> QUANT8_SYMM_PER_CHANNEL map 1929 .quant8ChannelOperands = {}, 1930 // int -> QUANT16_ASYMM map 1931 .quant16AsymmOperands = {}, 1932 // int -> QUANT8_SYMM map 1933 .quant8SymmOperands = {}, 1934 } 1935 }, 1936 }, // End of an example 1937 }; 1938 return examples_nhwc_relu1_quant8_weight_as_input; 1939 }; 1940 1941 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_2() { 1942 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_2 = { 1943 // Begin of an example 1944 { 1945 .operands = { 1946 //Input(s) 1947 { // See tools/test_generator/include/TestHarness.h:MixedTyped 1948 // int -> Dimensions map 1949 .operandDimensions = {{0, {1, 2, 2, 1}}}, 1950 // int -> FLOAT32 map 1951 .float32Operands = {}, 1952 // int -> INT32 map 1953 .int32Operands = {}, 1954 // int -> QUANT8_ASYMM map 1955 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 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, 5, 5, 2}}}, 1973 // int -> FLOAT32 map 1974 .float32Operands = {}, 1975 // int -> INT32 map 1976 .int32Operands = {}, 1977 // int -> QUANT8_ASYMM map 1978 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 1979 // int -> QUANT16_SYMM map 1980 .quant16SymmOperands = {}, 1981 // int -> FLOAT16 map 1982 .float16Operands = {}, 1983 // int -> BOOL8 map 1984 .bool8Operands = {}, 1985 // int -> QUANT8_SYMM_PER_CHANNEL map 1986 .quant8ChannelOperands = {}, 1987 // int -> QUANT16_ASYMM map 1988 .quant16AsymmOperands = {}, 1989 // int -> QUANT8_SYMM map 1990 .quant8SymmOperands = {}, 1991 } 1992 }, 1993 }, // End of an example 1994 }; 1995 return examples_nhwc_relu1_quant8_2; 1996 }; 1997 1998 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_quant8_weight_as_input_2() { 1999 static std::vector<MixedTypedExample> examples_nhwc_relu1_quant8_weight_as_input_2 = { 2000 // Begin of an example 2001 { 2002 .operands = { 2003 //Input(s) 2004 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2005 // int -> Dimensions map 2006 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2007 // int -> FLOAT32 map 2008 .float32Operands = {}, 2009 // int -> INT32 map 2010 .int32Operands = {{2, {-6, -8}}}, 2011 // int -> QUANT8_ASYMM map 2012 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5, 2}}}, 2030 // int -> FLOAT32 map 2031 .float32Operands = {}, 2032 // int -> INT32 map 2033 .int32Operands = {}, 2034 // int -> QUANT8_ASYMM map 2035 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 2036 // int -> QUANT16_SYMM map 2037 .quant16SymmOperands = {}, 2038 // int -> FLOAT16 map 2039 .float16Operands = {}, 2040 // int -> BOOL8 map 2041 .bool8Operands = {}, 2042 // int -> QUANT8_SYMM_PER_CHANNEL map 2043 .quant8ChannelOperands = {}, 2044 // int -> QUANT16_ASYMM map 2045 .quant16AsymmOperands = {}, 2046 // int -> QUANT8_SYMM map 2047 .quant8SymmOperands = {}, 2048 } 2049 }, 2050 }, // End of an example 2051 }; 2052 return examples_nhwc_relu1_quant8_weight_as_input_2; 2053 }; 2054 2055 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8() { 2056 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8 = { 2057 // Begin of an example 2058 { 2059 .operands = { 2060 //Input(s) 2061 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2062 // int -> Dimensions map 2063 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2064 // int -> FLOAT32 map 2065 .float32Operands = {}, 2066 // int -> INT32 map 2067 .int32Operands = {}, 2068 // int -> QUANT8_ASYMM map 2069 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 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, 5, 5, 2}}}, 2087 // int -> FLOAT32 map 2088 .float32Operands = {}, 2089 // int -> INT32 map 2090 .int32Operands = {}, 2091 // int -> QUANT8_ASYMM map 2092 .quant8AsymmOperands = {{0, {79, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 2093 // int -> QUANT16_SYMM map 2094 .quant16SymmOperands = {}, 2095 // int -> FLOAT16 map 2096 .float16Operands = {}, 2097 // int -> BOOL8 map 2098 .bool8Operands = {}, 2099 // int -> QUANT8_SYMM_PER_CHANNEL map 2100 .quant8ChannelOperands = {}, 2101 // int -> QUANT16_ASYMM map 2102 .quant16AsymmOperands = {}, 2103 // int -> QUANT8_SYMM map 2104 .quant8SymmOperands = {}, 2105 } 2106 }, 2107 }, // End of an example 2108 }; 2109 return examples_nhwc_relu1_channelQuant8; 2110 }; 2111 2112 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_weight_as_input() { 2113 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_weight_as_input = { 2114 // Begin of an example 2115 { 2116 .operands = { 2117 //Input(s) 2118 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2119 // int -> Dimensions map 2120 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2121 // int -> FLOAT32 map 2122 .float32Operands = {}, 2123 // int -> INT32 map 2124 .int32Operands = {{2, {-24, -16}}}, 2125 // int -> QUANT8_ASYMM map 2126 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 2127 // int -> QUANT16_SYMM map 2128 .quant16SymmOperands = {}, 2129 // int -> FLOAT16 map 2130 .float16Operands = {}, 2131 // int -> BOOL8 map 2132 .bool8Operands = {}, 2133 // int -> QUANT8_SYMM_PER_CHANNEL map 2134 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 2144 // int -> FLOAT32 map 2145 .float32Operands = {}, 2146 // int -> INT32 map 2147 .int32Operands = {}, 2148 // int -> QUANT8_ASYMM map 2149 .quant8AsymmOperands = {{0, {79, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 2150 // int -> QUANT16_SYMM map 2151 .quant16SymmOperands = {}, 2152 // int -> FLOAT16 map 2153 .float16Operands = {}, 2154 // int -> BOOL8 map 2155 .bool8Operands = {}, 2156 // int -> QUANT8_SYMM_PER_CHANNEL map 2157 .quant8ChannelOperands = {}, 2158 // int -> QUANT16_ASYMM map 2159 .quant16AsymmOperands = {}, 2160 // int -> QUANT8_SYMM map 2161 .quant8SymmOperands = {}, 2162 } 2163 }, 2164 }, // End of an example 2165 }; 2166 return examples_nhwc_relu1_channelQuant8_weight_as_input; 2167 }; 2168 2169 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_2() { 2170 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_2 = { 2171 // Begin of an example 2172 { 2173 .operands = { 2174 //Input(s) 2175 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2176 // int -> Dimensions map 2177 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2178 // int -> FLOAT32 map 2179 .float32Operands = {}, 2180 // int -> INT32 map 2181 .int32Operands = {}, 2182 // int -> QUANT8_ASYMM map 2183 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 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, 5, 5, 2}}}, 2201 // int -> FLOAT32 map 2202 .float32Operands = {}, 2203 // int -> INT32 map 2204 .int32Operands = {}, 2205 // int -> QUANT8_ASYMM map 2206 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 2207 // int -> QUANT16_SYMM map 2208 .quant16SymmOperands = {}, 2209 // int -> FLOAT16 map 2210 .float16Operands = {}, 2211 // int -> BOOL8 map 2212 .bool8Operands = {}, 2213 // int -> QUANT8_SYMM_PER_CHANNEL map 2214 .quant8ChannelOperands = {}, 2215 // int -> QUANT16_ASYMM map 2216 .quant16AsymmOperands = {}, 2217 // int -> QUANT8_SYMM map 2218 .quant8SymmOperands = {}, 2219 } 2220 }, 2221 }, // End of an example 2222 }; 2223 return examples_nhwc_relu1_channelQuant8_2; 2224 }; 2225 2226 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_channelQuant8_weight_as_input_2() { 2227 static std::vector<MixedTypedExample> examples_nhwc_relu1_channelQuant8_weight_as_input_2 = { 2228 // Begin of an example 2229 { 2230 .operands = { 2231 //Input(s) 2232 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2233 // int -> Dimensions map 2234 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2235 // int -> FLOAT32 map 2236 .float32Operands = {}, 2237 // int -> INT32 map 2238 .int32Operands = {{2, {-24, -16}}}, 2239 // int -> QUANT8_ASYMM map 2240 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 2241 // int -> QUANT16_SYMM map 2242 .quant16SymmOperands = {}, 2243 // int -> FLOAT16 map 2244 .float16Operands = {}, 2245 // int -> BOOL8 map 2246 .bool8Operands = {}, 2247 // int -> QUANT8_SYMM_PER_CHANNEL map 2248 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 2258 // int -> FLOAT32 map 2259 .float32Operands = {}, 2260 // int -> INT32 map 2261 .int32Operands = {}, 2262 // int -> QUANT8_ASYMM map 2263 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 2264 // int -> QUANT16_SYMM map 2265 .quant16SymmOperands = {}, 2266 // int -> FLOAT16 map 2267 .float16Operands = {}, 2268 // int -> BOOL8 map 2269 .bool8Operands = {}, 2270 // int -> QUANT8_SYMM_PER_CHANNEL map 2271 .quant8ChannelOperands = {}, 2272 // int -> QUANT16_ASYMM map 2273 .quant16AsymmOperands = {}, 2274 // int -> QUANT8_SYMM map 2275 .quant8SymmOperands = {}, 2276 } 2277 }, 2278 }, // End of an example 2279 }; 2280 return examples_nhwc_relu1_channelQuant8_weight_as_input_2; 2281 }; 2282 2283 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_float16() { 2284 static std::vector<MixedTypedExample> examples_nhwc_relu1_float16 = { 2285 // Begin of an example 2286 { 2287 .operands = { 2288 //Input(s) 2289 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2290 // int -> Dimensions map 2291 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2292 // int -> FLOAT32 map 2293 .float32Operands = {}, 2294 // int -> INT32 map 2295 .int32Operands = {}, 2296 // int -> QUANT8_ASYMM map 2297 .quant8AsymmOperands = {}, 2298 // int -> QUANT16_SYMM map 2299 .quant16SymmOperands = {}, 2300 // int -> FLOAT16 map 2301 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 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, 5, 5, 2}}}, 2315 // int -> FLOAT32 map 2316 .float32Operands = {}, 2317 // int -> INT32 map 2318 .int32Operands = {}, 2319 // int -> QUANT8_ASYMM map 2320 .quant8AsymmOperands = {}, 2321 // int -> QUANT16_SYMM map 2322 .quant16SymmOperands = {}, 2323 // int -> FLOAT16 map 2324 .float16Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 2325 // int -> BOOL8 map 2326 .bool8Operands = {}, 2327 // int -> QUANT8_SYMM_PER_CHANNEL map 2328 .quant8ChannelOperands = {}, 2329 // int -> QUANT16_ASYMM map 2330 .quant16AsymmOperands = {}, 2331 // int -> QUANT8_SYMM map 2332 .quant8SymmOperands = {}, 2333 } 2334 }, 2335 }, // End of an example 2336 }; 2337 return examples_nhwc_relu1_float16; 2338 }; 2339 2340 std::vector<MixedTypedExample>& get_examples_nhwc_relu1_float16_weight_as_input() { 2341 static std::vector<MixedTypedExample> examples_nhwc_relu1_float16_weight_as_input = { 2342 // Begin of an example 2343 { 2344 .operands = { 2345 //Input(s) 2346 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2347 // int -> Dimensions map 2348 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2349 // int -> FLOAT32 map 2350 .float32Operands = {}, 2351 // int -> INT32 map 2352 .int32Operands = {}, 2353 // int -> QUANT8_ASYMM map 2354 .quant8AsymmOperands = {}, 2355 // int -> QUANT16_SYMM map 2356 .quant16SymmOperands = {}, 2357 // int -> FLOAT16 map 2358 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 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, 5, 5, 2}}}, 2372 // int -> FLOAT32 map 2373 .float32Operands = {}, 2374 // int -> INT32 map 2375 .int32Operands = {}, 2376 // int -> QUANT8_ASYMM map 2377 .quant8AsymmOperands = {}, 2378 // int -> QUANT16_SYMM map 2379 .quant16SymmOperands = {}, 2380 // int -> FLOAT16 map 2381 .float16Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 2382 // int -> BOOL8 map 2383 .bool8Operands = {}, 2384 // int -> QUANT8_SYMM_PER_CHANNEL map 2385 .quant8ChannelOperands = {}, 2386 // int -> QUANT16_ASYMM map 2387 .quant16AsymmOperands = {}, 2388 // int -> QUANT8_SYMM map 2389 .quant8SymmOperands = {}, 2390 } 2391 }, 2392 }, // End of an example 2393 }; 2394 return examples_nhwc_relu1_float16_weight_as_input; 2395 }; 2396 2397 std::vector<MixedTypedExample>& get_examples_nhwc_relu6() { 2398 static std::vector<MixedTypedExample> examples_nhwc_relu6 = { 2399 // Begin of an example 2400 { 2401 .operands = { 2402 //Input(s) 2403 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2404 // int -> Dimensions map 2405 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2406 // int -> FLOAT32 map 2407 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 2408 // int -> INT32 map 2409 .int32Operands = {}, 2410 // int -> QUANT8_ASYMM map 2411 .quant8AsymmOperands = {}, 2412 // int -> QUANT16_SYMM map 2413 .quant16SymmOperands = {}, 2414 // int -> FLOAT16 map 2415 .float16Operands = {}, 2416 // int -> BOOL8 map 2417 .bool8Operands = {}, 2418 // int -> QUANT8_SYMM_PER_CHANNEL map 2419 .quant8ChannelOperands = {}, 2420 // int -> QUANT16_ASYMM map 2421 .quant16AsymmOperands = {}, 2422 // int -> QUANT8_SYMM map 2423 .quant8SymmOperands = {}, 2424 }, 2425 //Output(s) 2426 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2427 // int -> Dimensions map 2428 .operandDimensions = {{0, {1, 5, 5, 2}}}, 2429 // int -> FLOAT32 map 2430 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 2431 // int -> INT32 map 2432 .int32Operands = {}, 2433 // int -> QUANT8_ASYMM map 2434 .quant8AsymmOperands = {}, 2435 // int -> QUANT16_SYMM map 2436 .quant16SymmOperands = {}, 2437 // int -> FLOAT16 map 2438 .float16Operands = {}, 2439 // int -> BOOL8 map 2440 .bool8Operands = {}, 2441 // int -> QUANT8_SYMM_PER_CHANNEL map 2442 .quant8ChannelOperands = {}, 2443 // int -> QUANT16_ASYMM map 2444 .quant16AsymmOperands = {}, 2445 // int -> QUANT8_SYMM map 2446 .quant8SymmOperands = {}, 2447 } 2448 }, 2449 }, // End of an example 2450 }; 2451 return examples_nhwc_relu6; 2452 }; 2453 2454 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_weight_as_input() { 2455 static std::vector<MixedTypedExample> examples_nhwc_relu6_weight_as_input = { 2456 // Begin of an example 2457 { 2458 .operands = { 2459 //Input(s) 2460 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2461 // int -> Dimensions map 2462 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2463 // int -> FLOAT32 map 2464 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 2465 // int -> INT32 map 2466 .int32Operands = {}, 2467 // int -> QUANT8_ASYMM map 2468 .quant8AsymmOperands = {}, 2469 // int -> QUANT16_SYMM map 2470 .quant16SymmOperands = {}, 2471 // int -> FLOAT16 map 2472 .float16Operands = {}, 2473 // int -> BOOL8 map 2474 .bool8Operands = {}, 2475 // int -> QUANT8_SYMM_PER_CHANNEL map 2476 .quant8ChannelOperands = {}, 2477 // int -> QUANT16_ASYMM map 2478 .quant16AsymmOperands = {}, 2479 // int -> QUANT8_SYMM map 2480 .quant8SymmOperands = {}, 2481 }, 2482 //Output(s) 2483 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2484 // int -> Dimensions map 2485 .operandDimensions = {{0, {1, 5, 5, 2}}}, 2486 // int -> FLOAT32 map 2487 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 2488 // int -> INT32 map 2489 .int32Operands = {}, 2490 // int -> QUANT8_ASYMM map 2491 .quant8AsymmOperands = {}, 2492 // int -> QUANT16_SYMM map 2493 .quant16SymmOperands = {}, 2494 // int -> FLOAT16 map 2495 .float16Operands = {}, 2496 // int -> BOOL8 map 2497 .bool8Operands = {}, 2498 // int -> QUANT8_SYMM_PER_CHANNEL map 2499 .quant8ChannelOperands = {}, 2500 // int -> QUANT16_ASYMM map 2501 .quant16AsymmOperands = {}, 2502 // int -> QUANT8_SYMM map 2503 .quant8SymmOperands = {}, 2504 } 2505 }, 2506 }, // End of an example 2507 }; 2508 return examples_nhwc_relu6_weight_as_input; 2509 }; 2510 2511 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_relaxed() { 2512 static std::vector<MixedTypedExample> examples_nhwc_relu6_relaxed = { 2513 // Begin of an example 2514 { 2515 .operands = { 2516 //Input(s) 2517 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2518 // int -> Dimensions map 2519 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2520 // int -> FLOAT32 map 2521 .float32Operands = {{0, {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, 5, 5, 2}}}, 2543 // int -> FLOAT32 map 2544 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 2545 // int -> INT32 map 2546 .int32Operands = {}, 2547 // int -> QUANT8_ASYMM map 2548 .quant8AsymmOperands = {}, 2549 // int -> QUANT16_SYMM map 2550 .quant16SymmOperands = {}, 2551 // int -> FLOAT16 map 2552 .float16Operands = {}, 2553 // int -> BOOL8 map 2554 .bool8Operands = {}, 2555 // int -> QUANT8_SYMM_PER_CHANNEL map 2556 .quant8ChannelOperands = {}, 2557 // int -> QUANT16_ASYMM map 2558 .quant16AsymmOperands = {}, 2559 // int -> QUANT8_SYMM map 2560 .quant8SymmOperands = {}, 2561 } 2562 }, 2563 }, // End of an example 2564 }; 2565 return examples_nhwc_relu6_relaxed; 2566 }; 2567 2568 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_relaxed_weight_as_input() { 2569 static std::vector<MixedTypedExample> examples_nhwc_relu6_relaxed_weight_as_input = { 2570 // Begin of an example 2571 { 2572 .operands = { 2573 //Input(s) 2574 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2575 // int -> Dimensions map 2576 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2577 // int -> FLOAT32 map 2578 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 5, 5, 2}}}, 2600 // int -> FLOAT32 map 2601 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 2602 // int -> INT32 map 2603 .int32Operands = {}, 2604 // int -> QUANT8_ASYMM map 2605 .quant8AsymmOperands = {}, 2606 // int -> QUANT16_SYMM map 2607 .quant16SymmOperands = {}, 2608 // int -> FLOAT16 map 2609 .float16Operands = {}, 2610 // int -> BOOL8 map 2611 .bool8Operands = {}, 2612 // int -> QUANT8_SYMM_PER_CHANNEL map 2613 .quant8ChannelOperands = {}, 2614 // int -> QUANT16_ASYMM map 2615 .quant16AsymmOperands = {}, 2616 // int -> QUANT8_SYMM map 2617 .quant8SymmOperands = {}, 2618 } 2619 }, 2620 }, // End of an example 2621 }; 2622 return examples_nhwc_relu6_relaxed_weight_as_input; 2623 }; 2624 2625 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8() { 2626 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8 = { 2627 // Begin of an example 2628 { 2629 .operands = { 2630 //Input(s) 2631 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2632 // int -> Dimensions map 2633 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2634 // int -> FLOAT32 map 2635 .float32Operands = {}, 2636 // int -> INT32 map 2637 .int32Operands = {}, 2638 // int -> QUANT8_ASYMM map 2639 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 2640 // int -> QUANT16_SYMM map 2641 .quant16SymmOperands = {}, 2642 // int -> FLOAT16 map 2643 .float16Operands = {}, 2644 // int -> BOOL8 map 2645 .bool8Operands = {}, 2646 // int -> QUANT8_SYMM_PER_CHANNEL map 2647 .quant8ChannelOperands = {}, 2648 // int -> QUANT16_ASYMM map 2649 .quant16AsymmOperands = {}, 2650 // int -> QUANT8_SYMM map 2651 .quant8SymmOperands = {}, 2652 }, 2653 //Output(s) 2654 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2655 // int -> Dimensions map 2656 .operandDimensions = {{0, {1, 5, 5, 2}}}, 2657 // int -> FLOAT32 map 2658 .float32Operands = {}, 2659 // int -> INT32 map 2660 .int32Operands = {}, 2661 // int -> QUANT8_ASYMM map 2662 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 12, 9, 12, 12, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 2663 // int -> QUANT16_SYMM map 2664 .quant16SymmOperands = {}, 2665 // int -> FLOAT16 map 2666 .float16Operands = {}, 2667 // int -> BOOL8 map 2668 .bool8Operands = {}, 2669 // int -> QUANT8_SYMM_PER_CHANNEL map 2670 .quant8ChannelOperands = {}, 2671 // int -> QUANT16_ASYMM map 2672 .quant16AsymmOperands = {}, 2673 // int -> QUANT8_SYMM map 2674 .quant8SymmOperands = {}, 2675 } 2676 }, 2677 }, // End of an example 2678 }; 2679 return examples_nhwc_relu6_quant8; 2680 }; 2681 2682 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_weight_as_input() { 2683 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_weight_as_input = { 2684 // Begin of an example 2685 { 2686 .operands = { 2687 //Input(s) 2688 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2689 // int -> Dimensions map 2690 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2691 // int -> FLOAT32 map 2692 .float32Operands = {}, 2693 // int -> INT32 map 2694 .int32Operands = {{2, {-6, -8}}}, 2695 // int -> QUANT8_ASYMM map 2696 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 2714 // int -> FLOAT32 map 2715 .float32Operands = {}, 2716 // int -> INT32 map 2717 .int32Operands = {}, 2718 // int -> QUANT8_ASYMM map 2719 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 12, 9, 12, 12, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 2720 // int -> QUANT16_SYMM map 2721 .quant16SymmOperands = {}, 2722 // int -> FLOAT16 map 2723 .float16Operands = {}, 2724 // int -> BOOL8 map 2725 .bool8Operands = {}, 2726 // int -> QUANT8_SYMM_PER_CHANNEL map 2727 .quant8ChannelOperands = {}, 2728 // int -> QUANT16_ASYMM map 2729 .quant16AsymmOperands = {}, 2730 // int -> QUANT8_SYMM map 2731 .quant8SymmOperands = {}, 2732 } 2733 }, 2734 }, // End of an example 2735 }; 2736 return examples_nhwc_relu6_quant8_weight_as_input; 2737 }; 2738 2739 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_2() { 2740 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_2 = { 2741 // Begin of an example 2742 { 2743 .operands = { 2744 //Input(s) 2745 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2746 // int -> Dimensions map 2747 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2748 // int -> FLOAT32 map 2749 .float32Operands = {}, 2750 // int -> INT32 map 2751 .int32Operands = {}, 2752 // int -> QUANT8_ASYMM map 2753 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 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, 5, 5, 2}}}, 2771 // int -> FLOAT32 map 2772 .float32Operands = {}, 2773 // int -> INT32 map 2774 .int32Operands = {}, 2775 // int -> QUANT8_ASYMM map 2776 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 2777 // int -> QUANT16_SYMM map 2778 .quant16SymmOperands = {}, 2779 // int -> FLOAT16 map 2780 .float16Operands = {}, 2781 // int -> BOOL8 map 2782 .bool8Operands = {}, 2783 // int -> QUANT8_SYMM_PER_CHANNEL map 2784 .quant8ChannelOperands = {}, 2785 // int -> QUANT16_ASYMM map 2786 .quant16AsymmOperands = {}, 2787 // int -> QUANT8_SYMM map 2788 .quant8SymmOperands = {}, 2789 } 2790 }, 2791 }, // End of an example 2792 }; 2793 return examples_nhwc_relu6_quant8_2; 2794 }; 2795 2796 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_quant8_weight_as_input_2() { 2797 static std::vector<MixedTypedExample> examples_nhwc_relu6_quant8_weight_as_input_2 = { 2798 // Begin of an example 2799 { 2800 .operands = { 2801 //Input(s) 2802 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2803 // int -> Dimensions map 2804 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2805 // int -> FLOAT32 map 2806 .float32Operands = {}, 2807 // int -> INT32 map 2808 .int32Operands = {{2, {-6, -8}}}, 2809 // int -> QUANT8_ASYMM map 2810 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5, 2}}}, 2828 // int -> FLOAT32 map 2829 .float32Operands = {}, 2830 // int -> INT32 map 2831 .int32Operands = {}, 2832 // int -> QUANT8_ASYMM map 2833 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 2834 // int -> QUANT16_SYMM map 2835 .quant16SymmOperands = {}, 2836 // int -> FLOAT16 map 2837 .float16Operands = {}, 2838 // int -> BOOL8 map 2839 .bool8Operands = {}, 2840 // int -> QUANT8_SYMM_PER_CHANNEL map 2841 .quant8ChannelOperands = {}, 2842 // int -> QUANT16_ASYMM map 2843 .quant16AsymmOperands = {}, 2844 // int -> QUANT8_SYMM map 2845 .quant8SymmOperands = {}, 2846 } 2847 }, 2848 }, // End of an example 2849 }; 2850 return examples_nhwc_relu6_quant8_weight_as_input_2; 2851 }; 2852 2853 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8() { 2854 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8 = { 2855 // Begin of an example 2856 { 2857 .operands = { 2858 //Input(s) 2859 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2860 // int -> Dimensions map 2861 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2862 // int -> FLOAT32 map 2863 .float32Operands = {}, 2864 // int -> INT32 map 2865 .int32Operands = {}, 2866 // int -> QUANT8_ASYMM map 2867 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 2868 // int -> QUANT16_SYMM map 2869 .quant16SymmOperands = {}, 2870 // int -> FLOAT16 map 2871 .float16Operands = {}, 2872 // int -> BOOL8 map 2873 .bool8Operands = {}, 2874 // int -> QUANT8_SYMM_PER_CHANNEL map 2875 .quant8ChannelOperands = {}, 2876 // int -> QUANT16_ASYMM map 2877 .quant16AsymmOperands = {}, 2878 // int -> QUANT8_SYMM map 2879 .quant8SymmOperands = {}, 2880 }, 2881 //Output(s) 2882 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2883 // int -> Dimensions map 2884 .operandDimensions = {{0, {1, 5, 5, 2}}}, 2885 // int -> FLOAT32 map 2886 .float32Operands = {}, 2887 // int -> INT32 map 2888 .int32Operands = {}, 2889 // int -> QUANT8_ASYMM map 2890 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 92, 89, 92, 92, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 2891 // int -> QUANT16_SYMM map 2892 .quant16SymmOperands = {}, 2893 // int -> FLOAT16 map 2894 .float16Operands = {}, 2895 // int -> BOOL8 map 2896 .bool8Operands = {}, 2897 // int -> QUANT8_SYMM_PER_CHANNEL map 2898 .quant8ChannelOperands = {}, 2899 // int -> QUANT16_ASYMM map 2900 .quant16AsymmOperands = {}, 2901 // int -> QUANT8_SYMM map 2902 .quant8SymmOperands = {}, 2903 } 2904 }, 2905 }, // End of an example 2906 }; 2907 return examples_nhwc_relu6_channelQuant8; 2908 }; 2909 2910 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_weight_as_input() { 2911 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_weight_as_input = { 2912 // Begin of an example 2913 { 2914 .operands = { 2915 //Input(s) 2916 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2917 // int -> Dimensions map 2918 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 2919 // int -> FLOAT32 map 2920 .float32Operands = {}, 2921 // int -> INT32 map 2922 .int32Operands = {{2, {-24, -16}}}, 2923 // int -> QUANT8_ASYMM map 2924 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 2925 // int -> QUANT16_SYMM map 2926 .quant16SymmOperands = {}, 2927 // int -> FLOAT16 map 2928 .float16Operands = {}, 2929 // int -> BOOL8 map 2930 .bool8Operands = {}, 2931 // int -> QUANT8_SYMM_PER_CHANNEL map 2932 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 2942 // int -> FLOAT32 map 2943 .float32Operands = {}, 2944 // int -> INT32 map 2945 .int32Operands = {}, 2946 // int -> QUANT8_ASYMM map 2947 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 92, 89, 92, 92, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 2948 // int -> QUANT16_SYMM map 2949 .quant16SymmOperands = {}, 2950 // int -> FLOAT16 map 2951 .float16Operands = {}, 2952 // int -> BOOL8 map 2953 .bool8Operands = {}, 2954 // int -> QUANT8_SYMM_PER_CHANNEL map 2955 .quant8ChannelOperands = {}, 2956 // int -> QUANT16_ASYMM map 2957 .quant16AsymmOperands = {}, 2958 // int -> QUANT8_SYMM map 2959 .quant8SymmOperands = {}, 2960 } 2961 }, 2962 }, // End of an example 2963 }; 2964 return examples_nhwc_relu6_channelQuant8_weight_as_input; 2965 }; 2966 2967 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_2() { 2968 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_2 = { 2969 // Begin of an example 2970 { 2971 .operands = { 2972 //Input(s) 2973 { // See tools/test_generator/include/TestHarness.h:MixedTyped 2974 // int -> Dimensions map 2975 .operandDimensions = {{0, {1, 2, 2, 1}}}, 2976 // int -> FLOAT32 map 2977 .float32Operands = {}, 2978 // int -> INT32 map 2979 .int32Operands = {}, 2980 // int -> QUANT8_ASYMM map 2981 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 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, 5, 5, 2}}}, 2999 // int -> FLOAT32 map 3000 .float32Operands = {}, 3001 // int -> INT32 map 3002 .int32Operands = {}, 3003 // int -> QUANT8_ASYMM map 3004 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 3005 // int -> QUANT16_SYMM map 3006 .quant16SymmOperands = {}, 3007 // int -> FLOAT16 map 3008 .float16Operands = {}, 3009 // int -> BOOL8 map 3010 .bool8Operands = {}, 3011 // int -> QUANT8_SYMM_PER_CHANNEL map 3012 .quant8ChannelOperands = {}, 3013 // int -> QUANT16_ASYMM map 3014 .quant16AsymmOperands = {}, 3015 // int -> QUANT8_SYMM map 3016 .quant8SymmOperands = {}, 3017 } 3018 }, 3019 }, // End of an example 3020 }; 3021 return examples_nhwc_relu6_channelQuant8_2; 3022 }; 3023 3024 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_channelQuant8_weight_as_input_2() { 3025 static std::vector<MixedTypedExample> examples_nhwc_relu6_channelQuant8_weight_as_input_2 = { 3026 // Begin of an example 3027 { 3028 .operands = { 3029 //Input(s) 3030 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3031 // int -> Dimensions map 3032 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3033 // int -> FLOAT32 map 3034 .float32Operands = {}, 3035 // int -> INT32 map 3036 .int32Operands = {{2, {-24, -16}}}, 3037 // int -> QUANT8_ASYMM map 3038 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 3039 // int -> QUANT16_SYMM map 3040 .quant16SymmOperands = {}, 3041 // int -> FLOAT16 map 3042 .float16Operands = {}, 3043 // int -> BOOL8 map 3044 .bool8Operands = {}, 3045 // int -> QUANT8_SYMM_PER_CHANNEL map 3046 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5, 2}}}, 3056 // int -> FLOAT32 map 3057 .float32Operands = {}, 3058 // int -> INT32 map 3059 .int32Operands = {}, 3060 // int -> QUANT8_ASYMM map 3061 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 3062 // int -> QUANT16_SYMM map 3063 .quant16SymmOperands = {}, 3064 // int -> FLOAT16 map 3065 .float16Operands = {}, 3066 // int -> BOOL8 map 3067 .bool8Operands = {}, 3068 // int -> QUANT8_SYMM_PER_CHANNEL map 3069 .quant8ChannelOperands = {}, 3070 // int -> QUANT16_ASYMM map 3071 .quant16AsymmOperands = {}, 3072 // int -> QUANT8_SYMM map 3073 .quant8SymmOperands = {}, 3074 } 3075 }, 3076 }, // End of an example 3077 }; 3078 return examples_nhwc_relu6_channelQuant8_weight_as_input_2; 3079 }; 3080 3081 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_float16() { 3082 static std::vector<MixedTypedExample> examples_nhwc_relu6_float16 = { 3083 // Begin of an example 3084 { 3085 .operands = { 3086 //Input(s) 3087 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3088 // int -> Dimensions map 3089 .operandDimensions = {{0, {1, 2, 2, 1}}}, 3090 // int -> FLOAT32 map 3091 .float32Operands = {}, 3092 // int -> INT32 map 3093 .int32Operands = {}, 3094 // int -> QUANT8_ASYMM map 3095 .quant8AsymmOperands = {}, 3096 // int -> QUANT16_SYMM map 3097 .quant16SymmOperands = {}, 3098 // int -> FLOAT16 map 3099 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 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, 5, 5, 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, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 3123 // int -> BOOL8 map 3124 .bool8Operands = {}, 3125 // int -> QUANT8_SYMM_PER_CHANNEL map 3126 .quant8ChannelOperands = {}, 3127 // int -> QUANT16_ASYMM map 3128 .quant16AsymmOperands = {}, 3129 // int -> QUANT8_SYMM map 3130 .quant8SymmOperands = {}, 3131 } 3132 }, 3133 }, // End of an example 3134 }; 3135 return examples_nhwc_relu6_float16; 3136 }; 3137 3138 std::vector<MixedTypedExample>& get_examples_nhwc_relu6_float16_weight_as_input() { 3139 static std::vector<MixedTypedExample> examples_nhwc_relu6_float16_weight_as_input = { 3140 // Begin of an example 3141 { 3142 .operands = { 3143 //Input(s) 3144 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3145 // int -> Dimensions map 3146 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3147 // int -> FLOAT32 map 3148 .float32Operands = {}, 3149 // int -> INT32 map 3150 .int32Operands = {}, 3151 // int -> QUANT8_ASYMM map 3152 .quant8AsymmOperands = {}, 3153 // int -> QUANT16_SYMM map 3154 .quant16SymmOperands = {}, 3155 // int -> FLOAT16 map 3156 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 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, 5, 5, 2}}}, 3170 // int -> FLOAT32 map 3171 .float32Operands = {}, 3172 // int -> INT32 map 3173 .int32Operands = {}, 3174 // int -> QUANT8_ASYMM map 3175 .quant8AsymmOperands = {}, 3176 // int -> QUANT16_SYMM map 3177 .quant16SymmOperands = {}, 3178 // int -> FLOAT16 map 3179 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 3180 // int -> BOOL8 map 3181 .bool8Operands = {}, 3182 // int -> QUANT8_SYMM_PER_CHANNEL map 3183 .quant8ChannelOperands = {}, 3184 // int -> QUANT16_ASYMM map 3185 .quant16AsymmOperands = {}, 3186 // int -> QUANT8_SYMM map 3187 .quant8SymmOperands = {}, 3188 } 3189 }, 3190 }, // End of an example 3191 }; 3192 return examples_nhwc_relu6_float16_weight_as_input; 3193 }; 3194 3195 std::vector<MixedTypedExample>& get_examples_nchw_none() { 3196 static std::vector<MixedTypedExample> examples_nchw_none = { 3197 // Begin of an example 3198 { 3199 .operands = { 3200 //Input(s) 3201 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3202 // int -> Dimensions map 3203 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3204 // int -> FLOAT32 map 3205 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.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, 5, 5}}}, 3227 // int -> FLOAT32 map 3228 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3229 // int -> INT32 map 3230 .int32Operands = {}, 3231 // int -> QUANT8_ASYMM map 3232 .quant8AsymmOperands = {}, 3233 // int -> QUANT16_SYMM map 3234 .quant16SymmOperands = {}, 3235 // int -> FLOAT16 map 3236 .float16Operands = {}, 3237 // int -> BOOL8 map 3238 .bool8Operands = {}, 3239 // int -> QUANT8_SYMM_PER_CHANNEL map 3240 .quant8ChannelOperands = {}, 3241 // int -> QUANT16_ASYMM map 3242 .quant16AsymmOperands = {}, 3243 // int -> QUANT8_SYMM map 3244 .quant8SymmOperands = {}, 3245 } 3246 }, 3247 }, // End of an example 3248 }; 3249 return examples_nchw_none; 3250 }; 3251 3252 std::vector<MixedTypedExample>& get_examples_nchw_none_weight_as_input() { 3253 static std::vector<MixedTypedExample> examples_nchw_none_weight_as_input = { 3254 // Begin of an example 3255 { 3256 .operands = { 3257 //Input(s) 3258 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3259 // int -> Dimensions map 3260 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3261 // int -> FLOAT32 map 3262 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 5, 5}}}, 3284 // int -> FLOAT32 map 3285 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3286 // int -> INT32 map 3287 .int32Operands = {}, 3288 // int -> QUANT8_ASYMM map 3289 .quant8AsymmOperands = {}, 3290 // int -> QUANT16_SYMM map 3291 .quant16SymmOperands = {}, 3292 // int -> FLOAT16 map 3293 .float16Operands = {}, 3294 // int -> BOOL8 map 3295 .bool8Operands = {}, 3296 // int -> QUANT8_SYMM_PER_CHANNEL map 3297 .quant8ChannelOperands = {}, 3298 // int -> QUANT16_ASYMM map 3299 .quant16AsymmOperands = {}, 3300 // int -> QUANT8_SYMM map 3301 .quant8SymmOperands = {}, 3302 } 3303 }, 3304 }, // End of an example 3305 }; 3306 return examples_nchw_none_weight_as_input; 3307 }; 3308 3309 std::vector<MixedTypedExample>& get_examples_nchw_none_relaxed() { 3310 static std::vector<MixedTypedExample> examples_nchw_none_relaxed = { 3311 // Begin of an example 3312 { 3313 .operands = { 3314 //Input(s) 3315 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3316 // int -> Dimensions map 3317 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3318 // int -> FLOAT32 map 3319 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3320 // int -> INT32 map 3321 .int32Operands = {}, 3322 // int -> QUANT8_ASYMM map 3323 .quant8AsymmOperands = {}, 3324 // int -> QUANT16_SYMM map 3325 .quant16SymmOperands = {}, 3326 // int -> FLOAT16 map 3327 .float16Operands = {}, 3328 // int -> BOOL8 map 3329 .bool8Operands = {}, 3330 // int -> QUANT8_SYMM_PER_CHANNEL map 3331 .quant8ChannelOperands = {}, 3332 // int -> QUANT16_ASYMM map 3333 .quant16AsymmOperands = {}, 3334 // int -> QUANT8_SYMM map 3335 .quant8SymmOperands = {}, 3336 }, 3337 //Output(s) 3338 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3339 // int -> Dimensions map 3340 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3341 // int -> FLOAT32 map 3342 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3343 // int -> INT32 map 3344 .int32Operands = {}, 3345 // int -> QUANT8_ASYMM map 3346 .quant8AsymmOperands = {}, 3347 // int -> QUANT16_SYMM map 3348 .quant16SymmOperands = {}, 3349 // int -> FLOAT16 map 3350 .float16Operands = {}, 3351 // int -> BOOL8 map 3352 .bool8Operands = {}, 3353 // int -> QUANT8_SYMM_PER_CHANNEL map 3354 .quant8ChannelOperands = {}, 3355 // int -> QUANT16_ASYMM map 3356 .quant16AsymmOperands = {}, 3357 // int -> QUANT8_SYMM map 3358 .quant8SymmOperands = {}, 3359 } 3360 }, 3361 }, // End of an example 3362 }; 3363 return examples_nchw_none_relaxed; 3364 }; 3365 3366 std::vector<MixedTypedExample>& get_examples_nchw_none_relaxed_weight_as_input() { 3367 static std::vector<MixedTypedExample> examples_nchw_none_relaxed_weight_as_input = { 3368 // Begin of an example 3369 { 3370 .operands = { 3371 //Input(s) 3372 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3373 // int -> Dimensions map 3374 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3375 // int -> FLOAT32 map 3376 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 3377 // int -> INT32 map 3378 .int32Operands = {}, 3379 // int -> QUANT8_ASYMM map 3380 .quant8AsymmOperands = {}, 3381 // int -> QUANT16_SYMM map 3382 .quant16SymmOperands = {}, 3383 // int -> FLOAT16 map 3384 .float16Operands = {}, 3385 // int -> BOOL8 map 3386 .bool8Operands = {}, 3387 // int -> QUANT8_SYMM_PER_CHANNEL map 3388 .quant8ChannelOperands = {}, 3389 // int -> QUANT16_ASYMM map 3390 .quant16AsymmOperands = {}, 3391 // int -> QUANT8_SYMM map 3392 .quant8SymmOperands = {}, 3393 }, 3394 //Output(s) 3395 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3396 // int -> Dimensions map 3397 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3398 // int -> FLOAT32 map 3399 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3400 // int -> INT32 map 3401 .int32Operands = {}, 3402 // int -> QUANT8_ASYMM map 3403 .quant8AsymmOperands = {}, 3404 // int -> QUANT16_SYMM map 3405 .quant16SymmOperands = {}, 3406 // int -> FLOAT16 map 3407 .float16Operands = {}, 3408 // int -> BOOL8 map 3409 .bool8Operands = {}, 3410 // int -> QUANT8_SYMM_PER_CHANNEL map 3411 .quant8ChannelOperands = {}, 3412 // int -> QUANT16_ASYMM map 3413 .quant16AsymmOperands = {}, 3414 // int -> QUANT8_SYMM map 3415 .quant8SymmOperands = {}, 3416 } 3417 }, 3418 }, // End of an example 3419 }; 3420 return examples_nchw_none_relaxed_weight_as_input; 3421 }; 3422 3423 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8() { 3424 static std::vector<MixedTypedExample> examples_nchw_none_quant8 = { 3425 // Begin of an example 3426 { 3427 .operands = { 3428 //Input(s) 3429 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3430 // int -> Dimensions map 3431 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3432 // int -> FLOAT32 map 3433 .float32Operands = {}, 3434 // int -> INT32 map 3435 .int32Operands = {}, 3436 // int -> QUANT8_ASYMM map 3437 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 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, 5, 5}}}, 3455 // int -> FLOAT32 map 3456 .float32Operands = {}, 3457 // int -> INT32 map 3458 .int32Operands = {}, 3459 // int -> QUANT8_ASYMM map 3460 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 3461 // int -> QUANT16_SYMM map 3462 .quant16SymmOperands = {}, 3463 // int -> FLOAT16 map 3464 .float16Operands = {}, 3465 // int -> BOOL8 map 3466 .bool8Operands = {}, 3467 // int -> QUANT8_SYMM_PER_CHANNEL map 3468 .quant8ChannelOperands = {}, 3469 // int -> QUANT16_ASYMM map 3470 .quant16AsymmOperands = {}, 3471 // int -> QUANT8_SYMM map 3472 .quant8SymmOperands = {}, 3473 } 3474 }, 3475 }, // End of an example 3476 }; 3477 return examples_nchw_none_quant8; 3478 }; 3479 3480 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_weight_as_input() { 3481 static std::vector<MixedTypedExample> examples_nchw_none_quant8_weight_as_input = { 3482 // Begin of an example 3483 { 3484 .operands = { 3485 //Input(s) 3486 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3487 // int -> Dimensions map 3488 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3489 // int -> FLOAT32 map 3490 .float32Operands = {}, 3491 // int -> INT32 map 3492 .int32Operands = {{2, {-6, -8}}}, 3493 // int -> QUANT8_ASYMM map 3494 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 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, 5, 5}}}, 3512 // int -> FLOAT32 map 3513 .float32Operands = {}, 3514 // int -> INT32 map 3515 .int32Operands = {}, 3516 // int -> QUANT8_ASYMM map 3517 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 3518 // int -> QUANT16_SYMM map 3519 .quant16SymmOperands = {}, 3520 // int -> FLOAT16 map 3521 .float16Operands = {}, 3522 // int -> BOOL8 map 3523 .bool8Operands = {}, 3524 // int -> QUANT8_SYMM_PER_CHANNEL map 3525 .quant8ChannelOperands = {}, 3526 // int -> QUANT16_ASYMM map 3527 .quant16AsymmOperands = {}, 3528 // int -> QUANT8_SYMM map 3529 .quant8SymmOperands = {}, 3530 } 3531 }, 3532 }, // End of an example 3533 }; 3534 return examples_nchw_none_quant8_weight_as_input; 3535 }; 3536 3537 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_2() { 3538 static std::vector<MixedTypedExample> examples_nchw_none_quant8_2 = { 3539 // Begin of an example 3540 { 3541 .operands = { 3542 //Input(s) 3543 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3544 // int -> Dimensions map 3545 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3546 // int -> FLOAT32 map 3547 .float32Operands = {}, 3548 // int -> INT32 map 3549 .int32Operands = {}, 3550 // int -> QUANT8_ASYMM map 3551 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 3552 // int -> QUANT16_SYMM map 3553 .quant16SymmOperands = {}, 3554 // int -> FLOAT16 map 3555 .float16Operands = {}, 3556 // int -> BOOL8 map 3557 .bool8Operands = {}, 3558 // int -> QUANT8_SYMM_PER_CHANNEL map 3559 .quant8ChannelOperands = {}, 3560 // int -> QUANT16_ASYMM map 3561 .quant16AsymmOperands = {}, 3562 // int -> QUANT8_SYMM map 3563 .quant8SymmOperands = {}, 3564 }, 3565 //Output(s) 3566 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3567 // int -> Dimensions map 3568 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3569 // int -> FLOAT32 map 3570 .float32Operands = {}, 3571 // int -> INT32 map 3572 .int32Operands = {}, 3573 // int -> QUANT8_ASYMM map 3574 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 3575 // int -> QUANT16_SYMM map 3576 .quant16SymmOperands = {}, 3577 // int -> FLOAT16 map 3578 .float16Operands = {}, 3579 // int -> BOOL8 map 3580 .bool8Operands = {}, 3581 // int -> QUANT8_SYMM_PER_CHANNEL map 3582 .quant8ChannelOperands = {}, 3583 // int -> QUANT16_ASYMM map 3584 .quant16AsymmOperands = {}, 3585 // int -> QUANT8_SYMM map 3586 .quant8SymmOperands = {}, 3587 } 3588 }, 3589 }, // End of an example 3590 }; 3591 return examples_nchw_none_quant8_2; 3592 }; 3593 3594 std::vector<MixedTypedExample>& get_examples_nchw_none_quant8_weight_as_input_2() { 3595 static std::vector<MixedTypedExample> examples_nchw_none_quant8_weight_as_input_2 = { 3596 // Begin of an example 3597 { 3598 .operands = { 3599 //Input(s) 3600 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3601 // int -> Dimensions map 3602 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3603 // int -> FLOAT32 map 3604 .float32Operands = {}, 3605 // int -> INT32 map 3606 .int32Operands = {{2, {-6, -8}}}, 3607 // int -> QUANT8_ASYMM map 3608 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5}}}, 3626 // int -> FLOAT32 map 3627 .float32Operands = {}, 3628 // int -> INT32 map 3629 .int32Operands = {}, 3630 // int -> QUANT8_ASYMM map 3631 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 3632 // int -> QUANT16_SYMM map 3633 .quant16SymmOperands = {}, 3634 // int -> FLOAT16 map 3635 .float16Operands = {}, 3636 // int -> BOOL8 map 3637 .bool8Operands = {}, 3638 // int -> QUANT8_SYMM_PER_CHANNEL map 3639 .quant8ChannelOperands = {}, 3640 // int -> QUANT16_ASYMM map 3641 .quant16AsymmOperands = {}, 3642 // int -> QUANT8_SYMM map 3643 .quant8SymmOperands = {}, 3644 } 3645 }, 3646 }, // End of an example 3647 }; 3648 return examples_nchw_none_quant8_weight_as_input_2; 3649 }; 3650 3651 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8() { 3652 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8 = { 3653 // Begin of an example 3654 { 3655 .operands = { 3656 //Input(s) 3657 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3658 // int -> Dimensions map 3659 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3660 // int -> FLOAT32 map 3661 .float32Operands = {}, 3662 // int -> INT32 map 3663 .int32Operands = {}, 3664 // int -> QUANT8_ASYMM map 3665 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 3666 // int -> QUANT16_SYMM map 3667 .quant16SymmOperands = {}, 3668 // int -> FLOAT16 map 3669 .float16Operands = {}, 3670 // int -> BOOL8 map 3671 .bool8Operands = {}, 3672 // int -> QUANT8_SYMM_PER_CHANNEL map 3673 .quant8ChannelOperands = {}, 3674 // int -> QUANT16_ASYMM map 3675 .quant16AsymmOperands = {}, 3676 // int -> QUANT8_SYMM map 3677 .quant8SymmOperands = {}, 3678 }, 3679 //Output(s) 3680 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3681 // int -> Dimensions map 3682 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3683 // int -> FLOAT32 map 3684 .float32Operands = {}, 3685 // int -> INT32 map 3686 .int32Operands = {}, 3687 // int -> QUANT8_ASYMM map 3688 .quant8AsymmOperands = {{0, {79, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 3689 // int -> QUANT16_SYMM map 3690 .quant16SymmOperands = {}, 3691 // int -> FLOAT16 map 3692 .float16Operands = {}, 3693 // int -> BOOL8 map 3694 .bool8Operands = {}, 3695 // int -> QUANT8_SYMM_PER_CHANNEL map 3696 .quant8ChannelOperands = {}, 3697 // int -> QUANT16_ASYMM map 3698 .quant16AsymmOperands = {}, 3699 // int -> QUANT8_SYMM map 3700 .quant8SymmOperands = {}, 3701 } 3702 }, 3703 }, // End of an example 3704 }; 3705 return examples_nchw_none_channelQuant8; 3706 }; 3707 3708 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_weight_as_input() { 3709 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_weight_as_input = { 3710 // Begin of an example 3711 { 3712 .operands = { 3713 //Input(s) 3714 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3715 // int -> Dimensions map 3716 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3717 // int -> FLOAT32 map 3718 .float32Operands = {}, 3719 // int -> INT32 map 3720 .int32Operands = {{2, {-24, -16}}}, 3721 // int -> QUANT8_ASYMM map 3722 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 3723 // int -> QUANT16_SYMM map 3724 .quant16SymmOperands = {}, 3725 // int -> FLOAT16 map 3726 .float16Operands = {}, 3727 // int -> BOOL8 map 3728 .bool8Operands = {}, 3729 // int -> QUANT8_SYMM_PER_CHANNEL map 3730 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 3731 // int -> QUANT16_ASYMM map 3732 .quant16AsymmOperands = {}, 3733 // int -> QUANT8_SYMM map 3734 .quant8SymmOperands = {}, 3735 }, 3736 //Output(s) 3737 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3738 // int -> Dimensions map 3739 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3740 // int -> FLOAT32 map 3741 .float32Operands = {}, 3742 // int -> INT32 map 3743 .int32Operands = {}, 3744 // int -> QUANT8_ASYMM map 3745 .quant8AsymmOperands = {{0, {79, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 3746 // int -> QUANT16_SYMM map 3747 .quant16SymmOperands = {}, 3748 // int -> FLOAT16 map 3749 .float16Operands = {}, 3750 // int -> BOOL8 map 3751 .bool8Operands = {}, 3752 // int -> QUANT8_SYMM_PER_CHANNEL map 3753 .quant8ChannelOperands = {}, 3754 // int -> QUANT16_ASYMM map 3755 .quant16AsymmOperands = {}, 3756 // int -> QUANT8_SYMM map 3757 .quant8SymmOperands = {}, 3758 } 3759 }, 3760 }, // End of an example 3761 }; 3762 return examples_nchw_none_channelQuant8_weight_as_input; 3763 }; 3764 3765 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_2() { 3766 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_2 = { 3767 // Begin of an example 3768 { 3769 .operands = { 3770 //Input(s) 3771 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3772 // int -> Dimensions map 3773 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3774 // int -> FLOAT32 map 3775 .float32Operands = {}, 3776 // int -> INT32 map 3777 .int32Operands = {}, 3778 // int -> QUANT8_ASYMM map 3779 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 3780 // int -> QUANT16_SYMM map 3781 .quant16SymmOperands = {}, 3782 // int -> FLOAT16 map 3783 .float16Operands = {}, 3784 // int -> BOOL8 map 3785 .bool8Operands = {}, 3786 // int -> QUANT8_SYMM_PER_CHANNEL map 3787 .quant8ChannelOperands = {}, 3788 // int -> QUANT16_ASYMM map 3789 .quant16AsymmOperands = {}, 3790 // int -> QUANT8_SYMM map 3791 .quant8SymmOperands = {}, 3792 }, 3793 //Output(s) 3794 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3795 // int -> Dimensions map 3796 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3797 // int -> FLOAT32 map 3798 .float32Operands = {}, 3799 // int -> INT32 map 3800 .int32Operands = {}, 3801 // int -> QUANT8_ASYMM map 3802 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 3803 // int -> QUANT16_SYMM map 3804 .quant16SymmOperands = {}, 3805 // int -> FLOAT16 map 3806 .float16Operands = {}, 3807 // int -> BOOL8 map 3808 .bool8Operands = {}, 3809 // int -> QUANT8_SYMM_PER_CHANNEL map 3810 .quant8ChannelOperands = {}, 3811 // int -> QUANT16_ASYMM map 3812 .quant16AsymmOperands = {}, 3813 // int -> QUANT8_SYMM map 3814 .quant8SymmOperands = {}, 3815 } 3816 }, 3817 }, // End of an example 3818 }; 3819 return examples_nchw_none_channelQuant8_2; 3820 }; 3821 3822 std::vector<MixedTypedExample>& get_examples_nchw_none_channelQuant8_weight_as_input_2() { 3823 static std::vector<MixedTypedExample> examples_nchw_none_channelQuant8_weight_as_input_2 = { 3824 // Begin of an example 3825 { 3826 .operands = { 3827 //Input(s) 3828 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3829 // int -> Dimensions map 3830 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3831 // int -> FLOAT32 map 3832 .float32Operands = {}, 3833 // int -> INT32 map 3834 .int32Operands = {{2, {-24, -16}}}, 3835 // int -> QUANT8_ASYMM map 3836 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 3837 // int -> QUANT16_SYMM map 3838 .quant16SymmOperands = {}, 3839 // int -> FLOAT16 map 3840 .float16Operands = {}, 3841 // int -> BOOL8 map 3842 .bool8Operands = {}, 3843 // int -> QUANT8_SYMM_PER_CHANNEL map 3844 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 3845 // int -> QUANT16_ASYMM map 3846 .quant16AsymmOperands = {}, 3847 // int -> QUANT8_SYMM map 3848 .quant8SymmOperands = {}, 3849 }, 3850 //Output(s) 3851 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3852 // int -> Dimensions map 3853 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3854 // int -> FLOAT32 map 3855 .float32Operands = {}, 3856 // int -> INT32 map 3857 .int32Operands = {}, 3858 // int -> QUANT8_ASYMM map 3859 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 3860 // int -> QUANT16_SYMM map 3861 .quant16SymmOperands = {}, 3862 // int -> FLOAT16 map 3863 .float16Operands = {}, 3864 // int -> BOOL8 map 3865 .bool8Operands = {}, 3866 // int -> QUANT8_SYMM_PER_CHANNEL map 3867 .quant8ChannelOperands = {}, 3868 // int -> QUANT16_ASYMM map 3869 .quant16AsymmOperands = {}, 3870 // int -> QUANT8_SYMM map 3871 .quant8SymmOperands = {}, 3872 } 3873 }, 3874 }, // End of an example 3875 }; 3876 return examples_nchw_none_channelQuant8_weight_as_input_2; 3877 }; 3878 3879 std::vector<MixedTypedExample>& get_examples_nchw_none_float16() { 3880 static std::vector<MixedTypedExample> examples_nchw_none_float16 = { 3881 // Begin of an example 3882 { 3883 .operands = { 3884 //Input(s) 3885 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3886 // int -> Dimensions map 3887 .operandDimensions = {{0, {1, 1, 2, 2}}}, 3888 // int -> FLOAT32 map 3889 .float32Operands = {}, 3890 // int -> INT32 map 3891 .int32Operands = {}, 3892 // int -> QUANT8_ASYMM map 3893 .quant8AsymmOperands = {}, 3894 // int -> QUANT16_SYMM map 3895 .quant16SymmOperands = {}, 3896 // int -> FLOAT16 map 3897 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 3898 // int -> BOOL8 map 3899 .bool8Operands = {}, 3900 // int -> QUANT8_SYMM_PER_CHANNEL map 3901 .quant8ChannelOperands = {}, 3902 // int -> QUANT16_ASYMM map 3903 .quant16AsymmOperands = {}, 3904 // int -> QUANT8_SYMM map 3905 .quant8SymmOperands = {}, 3906 }, 3907 //Output(s) 3908 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3909 // int -> Dimensions map 3910 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3911 // int -> FLOAT32 map 3912 .float32Operands = {}, 3913 // int -> INT32 map 3914 .int32Operands = {}, 3915 // int -> QUANT8_ASYMM map 3916 .quant8AsymmOperands = {}, 3917 // int -> QUANT16_SYMM map 3918 .quant16SymmOperands = {}, 3919 // int -> FLOAT16 map 3920 .float16Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3921 // int -> BOOL8 map 3922 .bool8Operands = {}, 3923 // int -> QUANT8_SYMM_PER_CHANNEL map 3924 .quant8ChannelOperands = {}, 3925 // int -> QUANT16_ASYMM map 3926 .quant16AsymmOperands = {}, 3927 // int -> QUANT8_SYMM map 3928 .quant8SymmOperands = {}, 3929 } 3930 }, 3931 }, // End of an example 3932 }; 3933 return examples_nchw_none_float16; 3934 }; 3935 3936 std::vector<MixedTypedExample>& get_examples_nchw_none_float16_weight_as_input() { 3937 static std::vector<MixedTypedExample> examples_nchw_none_float16_weight_as_input = { 3938 // Begin of an example 3939 { 3940 .operands = { 3941 //Input(s) 3942 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3943 // int -> Dimensions map 3944 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 3945 // int -> FLOAT32 map 3946 .float32Operands = {}, 3947 // int -> INT32 map 3948 .int32Operands = {}, 3949 // int -> QUANT8_ASYMM map 3950 .quant8AsymmOperands = {}, 3951 // int -> QUANT16_SYMM map 3952 .quant16SymmOperands = {}, 3953 // int -> FLOAT16 map 3954 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 3955 // int -> BOOL8 map 3956 .bool8Operands = {}, 3957 // int -> QUANT8_SYMM_PER_CHANNEL map 3958 .quant8ChannelOperands = {}, 3959 // int -> QUANT16_ASYMM map 3960 .quant16AsymmOperands = {}, 3961 // int -> QUANT8_SYMM map 3962 .quant8SymmOperands = {}, 3963 }, 3964 //Output(s) 3965 { // See tools/test_generator/include/TestHarness.h:MixedTyped 3966 // int -> Dimensions map 3967 .operandDimensions = {{0, {1, 2, 5, 5}}}, 3968 // int -> FLOAT32 map 3969 .float32Operands = {}, 3970 // int -> INT32 map 3971 .int32Operands = {}, 3972 // int -> QUANT8_ASYMM map 3973 .quant8AsymmOperands = {}, 3974 // int -> QUANT16_SYMM map 3975 .quant16SymmOperands = {}, 3976 // int -> FLOAT16 map 3977 .float16Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 3978 // int -> BOOL8 map 3979 .bool8Operands = {}, 3980 // int -> QUANT8_SYMM_PER_CHANNEL map 3981 .quant8ChannelOperands = {}, 3982 // int -> QUANT16_ASYMM map 3983 .quant16AsymmOperands = {}, 3984 // int -> QUANT8_SYMM map 3985 .quant8SymmOperands = {}, 3986 } 3987 }, 3988 }, // End of an example 3989 }; 3990 return examples_nchw_none_float16_weight_as_input; 3991 }; 3992 3993 std::vector<MixedTypedExample>& get_examples_nchw_relu() { 3994 static std::vector<MixedTypedExample> examples_nchw_relu = { 3995 // Begin of an example 3996 { 3997 .operands = { 3998 //Input(s) 3999 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4000 // int -> Dimensions map 4001 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4002 // int -> FLOAT32 map 4003 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 4004 // int -> INT32 map 4005 .int32Operands = {}, 4006 // int -> QUANT8_ASYMM map 4007 .quant8AsymmOperands = {}, 4008 // int -> QUANT16_SYMM map 4009 .quant16SymmOperands = {}, 4010 // int -> FLOAT16 map 4011 .float16Operands = {}, 4012 // int -> BOOL8 map 4013 .bool8Operands = {}, 4014 // int -> QUANT8_SYMM_PER_CHANNEL map 4015 .quant8ChannelOperands = {}, 4016 // int -> QUANT16_ASYMM map 4017 .quant16AsymmOperands = {}, 4018 // int -> QUANT8_SYMM map 4019 .quant8SymmOperands = {}, 4020 }, 4021 //Output(s) 4022 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4023 // int -> Dimensions map 4024 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4025 // int -> FLOAT32 map 4026 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4027 // int -> INT32 map 4028 .int32Operands = {}, 4029 // int -> QUANT8_ASYMM map 4030 .quant8AsymmOperands = {}, 4031 // int -> QUANT16_SYMM map 4032 .quant16SymmOperands = {}, 4033 // int -> FLOAT16 map 4034 .float16Operands = {}, 4035 // int -> BOOL8 map 4036 .bool8Operands = {}, 4037 // int -> QUANT8_SYMM_PER_CHANNEL map 4038 .quant8ChannelOperands = {}, 4039 // int -> QUANT16_ASYMM map 4040 .quant16AsymmOperands = {}, 4041 // int -> QUANT8_SYMM map 4042 .quant8SymmOperands = {}, 4043 } 4044 }, 4045 }, // End of an example 4046 }; 4047 return examples_nchw_relu; 4048 }; 4049 4050 std::vector<MixedTypedExample>& get_examples_nchw_relu_weight_as_input() { 4051 static std::vector<MixedTypedExample> examples_nchw_relu_weight_as_input = { 4052 // Begin of an example 4053 { 4054 .operands = { 4055 //Input(s) 4056 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4057 // int -> Dimensions map 4058 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4059 // int -> FLOAT32 map 4060 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 4061 // int -> INT32 map 4062 .int32Operands = {}, 4063 // int -> QUANT8_ASYMM map 4064 .quant8AsymmOperands = {}, 4065 // int -> QUANT16_SYMM map 4066 .quant16SymmOperands = {}, 4067 // int -> FLOAT16 map 4068 .float16Operands = {}, 4069 // int -> BOOL8 map 4070 .bool8Operands = {}, 4071 // int -> QUANT8_SYMM_PER_CHANNEL map 4072 .quant8ChannelOperands = {}, 4073 // int -> QUANT16_ASYMM map 4074 .quant16AsymmOperands = {}, 4075 // int -> QUANT8_SYMM map 4076 .quant8SymmOperands = {}, 4077 }, 4078 //Output(s) 4079 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4080 // int -> Dimensions map 4081 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4082 // int -> FLOAT32 map 4083 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4084 // int -> INT32 map 4085 .int32Operands = {}, 4086 // int -> QUANT8_ASYMM map 4087 .quant8AsymmOperands = {}, 4088 // int -> QUANT16_SYMM map 4089 .quant16SymmOperands = {}, 4090 // int -> FLOAT16 map 4091 .float16Operands = {}, 4092 // int -> BOOL8 map 4093 .bool8Operands = {}, 4094 // int -> QUANT8_SYMM_PER_CHANNEL map 4095 .quant8ChannelOperands = {}, 4096 // int -> QUANT16_ASYMM map 4097 .quant16AsymmOperands = {}, 4098 // int -> QUANT8_SYMM map 4099 .quant8SymmOperands = {}, 4100 } 4101 }, 4102 }, // End of an example 4103 }; 4104 return examples_nchw_relu_weight_as_input; 4105 }; 4106 4107 std::vector<MixedTypedExample>& get_examples_nchw_relu_relaxed() { 4108 static std::vector<MixedTypedExample> examples_nchw_relu_relaxed = { 4109 // Begin of an example 4110 { 4111 .operands = { 4112 //Input(s) 4113 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4114 // int -> Dimensions map 4115 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4116 // int -> FLOAT32 map 4117 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.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, 5, 5}}}, 4139 // int -> FLOAT32 map 4140 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4141 // int -> INT32 map 4142 .int32Operands = {}, 4143 // int -> QUANT8_ASYMM map 4144 .quant8AsymmOperands = {}, 4145 // int -> QUANT16_SYMM map 4146 .quant16SymmOperands = {}, 4147 // int -> FLOAT16 map 4148 .float16Operands = {}, 4149 // int -> BOOL8 map 4150 .bool8Operands = {}, 4151 // int -> QUANT8_SYMM_PER_CHANNEL map 4152 .quant8ChannelOperands = {}, 4153 // int -> QUANT16_ASYMM map 4154 .quant16AsymmOperands = {}, 4155 // int -> QUANT8_SYMM map 4156 .quant8SymmOperands = {}, 4157 } 4158 }, 4159 }, // End of an example 4160 }; 4161 return examples_nchw_relu_relaxed; 4162 }; 4163 4164 std::vector<MixedTypedExample>& get_examples_nchw_relu_relaxed_weight_as_input() { 4165 static std::vector<MixedTypedExample> examples_nchw_relu_relaxed_weight_as_input = { 4166 // Begin of an example 4167 { 4168 .operands = { 4169 //Input(s) 4170 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4171 // int -> Dimensions map 4172 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4173 // int -> FLOAT32 map 4174 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 5, 5}}}, 4196 // int -> FLOAT32 map 4197 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4198 // int -> INT32 map 4199 .int32Operands = {}, 4200 // int -> QUANT8_ASYMM map 4201 .quant8AsymmOperands = {}, 4202 // int -> QUANT16_SYMM map 4203 .quant16SymmOperands = {}, 4204 // int -> FLOAT16 map 4205 .float16Operands = {}, 4206 // int -> BOOL8 map 4207 .bool8Operands = {}, 4208 // int -> QUANT8_SYMM_PER_CHANNEL map 4209 .quant8ChannelOperands = {}, 4210 // int -> QUANT16_ASYMM map 4211 .quant16AsymmOperands = {}, 4212 // int -> QUANT8_SYMM map 4213 .quant8SymmOperands = {}, 4214 } 4215 }, 4216 }, // End of an example 4217 }; 4218 return examples_nchw_relu_relaxed_weight_as_input; 4219 }; 4220 4221 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8() { 4222 static std::vector<MixedTypedExample> examples_nchw_relu_quant8 = { 4223 // Begin of an example 4224 { 4225 .operands = { 4226 //Input(s) 4227 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4228 // int -> Dimensions map 4229 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4230 // int -> FLOAT32 map 4231 .float32Operands = {}, 4232 // int -> INT32 map 4233 .int32Operands = {}, 4234 // int -> QUANT8_ASYMM map 4235 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 4236 // int -> QUANT16_SYMM map 4237 .quant16SymmOperands = {}, 4238 // int -> FLOAT16 map 4239 .float16Operands = {}, 4240 // int -> BOOL8 map 4241 .bool8Operands = {}, 4242 // int -> QUANT8_SYMM_PER_CHANNEL map 4243 .quant8ChannelOperands = {}, 4244 // int -> QUANT16_ASYMM map 4245 .quant16AsymmOperands = {}, 4246 // int -> QUANT8_SYMM map 4247 .quant8SymmOperands = {}, 4248 }, 4249 //Output(s) 4250 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4251 // int -> Dimensions map 4252 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4253 // int -> FLOAT32 map 4254 .float32Operands = {}, 4255 // int -> INT32 map 4256 .int32Operands = {}, 4257 // int -> QUANT8_ASYMM map 4258 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 4259 // int -> QUANT16_SYMM map 4260 .quant16SymmOperands = {}, 4261 // int -> FLOAT16 map 4262 .float16Operands = {}, 4263 // int -> BOOL8 map 4264 .bool8Operands = {}, 4265 // int -> QUANT8_SYMM_PER_CHANNEL map 4266 .quant8ChannelOperands = {}, 4267 // int -> QUANT16_ASYMM map 4268 .quant16AsymmOperands = {}, 4269 // int -> QUANT8_SYMM map 4270 .quant8SymmOperands = {}, 4271 } 4272 }, 4273 }, // End of an example 4274 }; 4275 return examples_nchw_relu_quant8; 4276 }; 4277 4278 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_weight_as_input() { 4279 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_weight_as_input = { 4280 // Begin of an example 4281 { 4282 .operands = { 4283 //Input(s) 4284 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4285 // int -> Dimensions map 4286 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4287 // int -> FLOAT32 map 4288 .float32Operands = {}, 4289 // int -> INT32 map 4290 .int32Operands = {{2, {-6, -8}}}, 4291 // int -> QUANT8_ASYMM map 4292 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 4293 // int -> QUANT16_SYMM map 4294 .quant16SymmOperands = {}, 4295 // int -> FLOAT16 map 4296 .float16Operands = {}, 4297 // int -> BOOL8 map 4298 .bool8Operands = {}, 4299 // int -> QUANT8_SYMM_PER_CHANNEL map 4300 .quant8ChannelOperands = {}, 4301 // int -> QUANT16_ASYMM map 4302 .quant16AsymmOperands = {}, 4303 // int -> QUANT8_SYMM map 4304 .quant8SymmOperands = {}, 4305 }, 4306 //Output(s) 4307 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4308 // int -> Dimensions map 4309 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4310 // int -> FLOAT32 map 4311 .float32Operands = {}, 4312 // int -> INT32 map 4313 .int32Operands = {}, 4314 // int -> QUANT8_ASYMM map 4315 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 4316 // int -> QUANT16_SYMM map 4317 .quant16SymmOperands = {}, 4318 // int -> FLOAT16 map 4319 .float16Operands = {}, 4320 // int -> BOOL8 map 4321 .bool8Operands = {}, 4322 // int -> QUANT8_SYMM_PER_CHANNEL map 4323 .quant8ChannelOperands = {}, 4324 // int -> QUANT16_ASYMM map 4325 .quant16AsymmOperands = {}, 4326 // int -> QUANT8_SYMM map 4327 .quant8SymmOperands = {}, 4328 } 4329 }, 4330 }, // End of an example 4331 }; 4332 return examples_nchw_relu_quant8_weight_as_input; 4333 }; 4334 4335 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_2() { 4336 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_2 = { 4337 // Begin of an example 4338 { 4339 .operands = { 4340 //Input(s) 4341 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4342 // int -> Dimensions map 4343 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4344 // int -> FLOAT32 map 4345 .float32Operands = {}, 4346 // int -> INT32 map 4347 .int32Operands = {}, 4348 // int -> QUANT8_ASYMM map 4349 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 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, 5, 5}}}, 4367 // int -> FLOAT32 map 4368 .float32Operands = {}, 4369 // int -> INT32 map 4370 .int32Operands = {}, 4371 // int -> QUANT8_ASYMM map 4372 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 4373 // int -> QUANT16_SYMM map 4374 .quant16SymmOperands = {}, 4375 // int -> FLOAT16 map 4376 .float16Operands = {}, 4377 // int -> BOOL8 map 4378 .bool8Operands = {}, 4379 // int -> QUANT8_SYMM_PER_CHANNEL map 4380 .quant8ChannelOperands = {}, 4381 // int -> QUANT16_ASYMM map 4382 .quant16AsymmOperands = {}, 4383 // int -> QUANT8_SYMM map 4384 .quant8SymmOperands = {}, 4385 } 4386 }, 4387 }, // End of an example 4388 }; 4389 return examples_nchw_relu_quant8_2; 4390 }; 4391 4392 std::vector<MixedTypedExample>& get_examples_nchw_relu_quant8_weight_as_input_2() { 4393 static std::vector<MixedTypedExample> examples_nchw_relu_quant8_weight_as_input_2 = { 4394 // Begin of an example 4395 { 4396 .operands = { 4397 //Input(s) 4398 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4399 // int -> Dimensions map 4400 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4401 // int -> FLOAT32 map 4402 .float32Operands = {}, 4403 // int -> INT32 map 4404 .int32Operands = {{2, {-6, -8}}}, 4405 // int -> QUANT8_ASYMM map 4406 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 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, 5, 5}}}, 4424 // int -> FLOAT32 map 4425 .float32Operands = {}, 4426 // int -> INT32 map 4427 .int32Operands = {}, 4428 // int -> QUANT8_ASYMM map 4429 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 4430 // int -> QUANT16_SYMM map 4431 .quant16SymmOperands = {}, 4432 // int -> FLOAT16 map 4433 .float16Operands = {}, 4434 // int -> BOOL8 map 4435 .bool8Operands = {}, 4436 // int -> QUANT8_SYMM_PER_CHANNEL map 4437 .quant8ChannelOperands = {}, 4438 // int -> QUANT16_ASYMM map 4439 .quant16AsymmOperands = {}, 4440 // int -> QUANT8_SYMM map 4441 .quant8SymmOperands = {}, 4442 } 4443 }, 4444 }, // End of an example 4445 }; 4446 return examples_nchw_relu_quant8_weight_as_input_2; 4447 }; 4448 4449 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8() { 4450 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8 = { 4451 // Begin of an example 4452 { 4453 .operands = { 4454 //Input(s) 4455 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4456 // int -> Dimensions map 4457 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4458 // int -> FLOAT32 map 4459 .float32Operands = {}, 4460 // int -> INT32 map 4461 .int32Operands = {}, 4462 // int -> QUANT8_ASYMM map 4463 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 4464 // int -> QUANT16_SYMM map 4465 .quant16SymmOperands = {}, 4466 // int -> FLOAT16 map 4467 .float16Operands = {}, 4468 // int -> BOOL8 map 4469 .bool8Operands = {}, 4470 // int -> QUANT8_SYMM_PER_CHANNEL map 4471 .quant8ChannelOperands = {}, 4472 // int -> QUANT16_ASYMM map 4473 .quant16AsymmOperands = {}, 4474 // int -> QUANT8_SYMM map 4475 .quant8SymmOperands = {}, 4476 }, 4477 //Output(s) 4478 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4479 // int -> Dimensions map 4480 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4481 // int -> FLOAT32 map 4482 .float32Operands = {}, 4483 // int -> INT32 map 4484 .int32Operands = {}, 4485 // int -> QUANT8_ASYMM map 4486 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 4487 // int -> QUANT16_SYMM map 4488 .quant16SymmOperands = {}, 4489 // int -> FLOAT16 map 4490 .float16Operands = {}, 4491 // int -> BOOL8 map 4492 .bool8Operands = {}, 4493 // int -> QUANT8_SYMM_PER_CHANNEL map 4494 .quant8ChannelOperands = {}, 4495 // int -> QUANT16_ASYMM map 4496 .quant16AsymmOperands = {}, 4497 // int -> QUANT8_SYMM map 4498 .quant8SymmOperands = {}, 4499 } 4500 }, 4501 }, // End of an example 4502 }; 4503 return examples_nchw_relu_channelQuant8; 4504 }; 4505 4506 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_weight_as_input() { 4507 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_weight_as_input = { 4508 // Begin of an example 4509 { 4510 .operands = { 4511 //Input(s) 4512 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4513 // int -> Dimensions map 4514 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4515 // int -> FLOAT32 map 4516 .float32Operands = {}, 4517 // int -> INT32 map 4518 .int32Operands = {{2, {-24, -16}}}, 4519 // int -> QUANT8_ASYMM map 4520 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 4521 // int -> QUANT16_SYMM map 4522 .quant16SymmOperands = {}, 4523 // int -> FLOAT16 map 4524 .float16Operands = {}, 4525 // int -> BOOL8 map 4526 .bool8Operands = {}, 4527 // int -> QUANT8_SYMM_PER_CHANNEL map 4528 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 4529 // int -> QUANT16_ASYMM map 4530 .quant16AsymmOperands = {}, 4531 // int -> QUANT8_SYMM map 4532 .quant8SymmOperands = {}, 4533 }, 4534 //Output(s) 4535 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4536 // int -> Dimensions map 4537 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4538 // int -> FLOAT32 map 4539 .float32Operands = {}, 4540 // int -> INT32 map 4541 .int32Operands = {}, 4542 // int -> QUANT8_ASYMM map 4543 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 4544 // int -> QUANT16_SYMM map 4545 .quant16SymmOperands = {}, 4546 // int -> FLOAT16 map 4547 .float16Operands = {}, 4548 // int -> BOOL8 map 4549 .bool8Operands = {}, 4550 // int -> QUANT8_SYMM_PER_CHANNEL map 4551 .quant8ChannelOperands = {}, 4552 // int -> QUANT16_ASYMM map 4553 .quant16AsymmOperands = {}, 4554 // int -> QUANT8_SYMM map 4555 .quant8SymmOperands = {}, 4556 } 4557 }, 4558 }, // End of an example 4559 }; 4560 return examples_nchw_relu_channelQuant8_weight_as_input; 4561 }; 4562 4563 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_2() { 4564 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_2 = { 4565 // Begin of an example 4566 { 4567 .operands = { 4568 //Input(s) 4569 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4570 // int -> Dimensions map 4571 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4572 // int -> FLOAT32 map 4573 .float32Operands = {}, 4574 // int -> INT32 map 4575 .int32Operands = {}, 4576 // int -> QUANT8_ASYMM map 4577 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 4578 // int -> QUANT16_SYMM map 4579 .quant16SymmOperands = {}, 4580 // int -> FLOAT16 map 4581 .float16Operands = {}, 4582 // int -> BOOL8 map 4583 .bool8Operands = {}, 4584 // int -> QUANT8_SYMM_PER_CHANNEL map 4585 .quant8ChannelOperands = {}, 4586 // int -> QUANT16_ASYMM map 4587 .quant16AsymmOperands = {}, 4588 // int -> QUANT8_SYMM map 4589 .quant8SymmOperands = {}, 4590 }, 4591 //Output(s) 4592 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4593 // int -> Dimensions map 4594 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4595 // int -> FLOAT32 map 4596 .float32Operands = {}, 4597 // int -> INT32 map 4598 .int32Operands = {}, 4599 // int -> QUANT8_ASYMM map 4600 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 4601 // int -> QUANT16_SYMM map 4602 .quant16SymmOperands = {}, 4603 // int -> FLOAT16 map 4604 .float16Operands = {}, 4605 // int -> BOOL8 map 4606 .bool8Operands = {}, 4607 // int -> QUANT8_SYMM_PER_CHANNEL map 4608 .quant8ChannelOperands = {}, 4609 // int -> QUANT16_ASYMM map 4610 .quant16AsymmOperands = {}, 4611 // int -> QUANT8_SYMM map 4612 .quant8SymmOperands = {}, 4613 } 4614 }, 4615 }, // End of an example 4616 }; 4617 return examples_nchw_relu_channelQuant8_2; 4618 }; 4619 4620 std::vector<MixedTypedExample>& get_examples_nchw_relu_channelQuant8_weight_as_input_2() { 4621 static std::vector<MixedTypedExample> examples_nchw_relu_channelQuant8_weight_as_input_2 = { 4622 // Begin of an example 4623 { 4624 .operands = { 4625 //Input(s) 4626 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4627 // int -> Dimensions map 4628 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4629 // int -> FLOAT32 map 4630 .float32Operands = {}, 4631 // int -> INT32 map 4632 .int32Operands = {{2, {-24, -16}}}, 4633 // int -> QUANT8_ASYMM map 4634 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 4635 // int -> QUANT16_SYMM map 4636 .quant16SymmOperands = {}, 4637 // int -> FLOAT16 map 4638 .float16Operands = {}, 4639 // int -> BOOL8 map 4640 .bool8Operands = {}, 4641 // int -> QUANT8_SYMM_PER_CHANNEL map 4642 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 4643 // int -> QUANT16_ASYMM map 4644 .quant16AsymmOperands = {}, 4645 // int -> QUANT8_SYMM map 4646 .quant8SymmOperands = {}, 4647 }, 4648 //Output(s) 4649 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4650 // int -> Dimensions map 4651 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4652 // int -> FLOAT32 map 4653 .float32Operands = {}, 4654 // int -> INT32 map 4655 .int32Operands = {}, 4656 // int -> QUANT8_ASYMM map 4657 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 4658 // int -> QUANT16_SYMM map 4659 .quant16SymmOperands = {}, 4660 // int -> FLOAT16 map 4661 .float16Operands = {}, 4662 // int -> BOOL8 map 4663 .bool8Operands = {}, 4664 // int -> QUANT8_SYMM_PER_CHANNEL map 4665 .quant8ChannelOperands = {}, 4666 // int -> QUANT16_ASYMM map 4667 .quant16AsymmOperands = {}, 4668 // int -> QUANT8_SYMM map 4669 .quant8SymmOperands = {}, 4670 } 4671 }, 4672 }, // End of an example 4673 }; 4674 return examples_nchw_relu_channelQuant8_weight_as_input_2; 4675 }; 4676 4677 std::vector<MixedTypedExample>& get_examples_nchw_relu_float16() { 4678 static std::vector<MixedTypedExample> examples_nchw_relu_float16 = { 4679 // Begin of an example 4680 { 4681 .operands = { 4682 //Input(s) 4683 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4684 // int -> Dimensions map 4685 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4686 // int -> FLOAT32 map 4687 .float32Operands = {}, 4688 // int -> INT32 map 4689 .int32Operands = {}, 4690 // int -> QUANT8_ASYMM map 4691 .quant8AsymmOperands = {}, 4692 // int -> QUANT16_SYMM map 4693 .quant16SymmOperands = {}, 4694 // int -> FLOAT16 map 4695 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 4696 // int -> BOOL8 map 4697 .bool8Operands = {}, 4698 // int -> QUANT8_SYMM_PER_CHANNEL map 4699 .quant8ChannelOperands = {}, 4700 // int -> QUANT16_ASYMM map 4701 .quant16AsymmOperands = {}, 4702 // int -> QUANT8_SYMM map 4703 .quant8SymmOperands = {}, 4704 }, 4705 //Output(s) 4706 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4707 // int -> Dimensions map 4708 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4709 // int -> FLOAT32 map 4710 .float32Operands = {}, 4711 // int -> INT32 map 4712 .int32Operands = {}, 4713 // int -> QUANT8_ASYMM map 4714 .quant8AsymmOperands = {}, 4715 // int -> QUANT16_SYMM map 4716 .quant16SymmOperands = {}, 4717 // int -> FLOAT16 map 4718 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4719 // int -> BOOL8 map 4720 .bool8Operands = {}, 4721 // int -> QUANT8_SYMM_PER_CHANNEL map 4722 .quant8ChannelOperands = {}, 4723 // int -> QUANT16_ASYMM map 4724 .quant16AsymmOperands = {}, 4725 // int -> QUANT8_SYMM map 4726 .quant8SymmOperands = {}, 4727 } 4728 }, 4729 }, // End of an example 4730 }; 4731 return examples_nchw_relu_float16; 4732 }; 4733 4734 std::vector<MixedTypedExample>& get_examples_nchw_relu_float16_weight_as_input() { 4735 static std::vector<MixedTypedExample> examples_nchw_relu_float16_weight_as_input = { 4736 // Begin of an example 4737 { 4738 .operands = { 4739 //Input(s) 4740 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4741 // int -> Dimensions map 4742 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4743 // int -> FLOAT32 map 4744 .float32Operands = {}, 4745 // int -> INT32 map 4746 .int32Operands = {}, 4747 // int -> QUANT8_ASYMM map 4748 .quant8AsymmOperands = {}, 4749 // int -> QUANT16_SYMM map 4750 .quant16SymmOperands = {}, 4751 // int -> FLOAT16 map 4752 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 2, 5, 5}}}, 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, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 4776 // int -> BOOL8 map 4777 .bool8Operands = {}, 4778 // int -> QUANT8_SYMM_PER_CHANNEL map 4779 .quant8ChannelOperands = {}, 4780 // int -> QUANT16_ASYMM map 4781 .quant16AsymmOperands = {}, 4782 // int -> QUANT8_SYMM map 4783 .quant8SymmOperands = {}, 4784 } 4785 }, 4786 }, // End of an example 4787 }; 4788 return examples_nchw_relu_float16_weight_as_input; 4789 }; 4790 4791 std::vector<MixedTypedExample>& get_examples_nchw_relu1() { 4792 static std::vector<MixedTypedExample> examples_nchw_relu1 = { 4793 // Begin of an example 4794 { 4795 .operands = { 4796 //Input(s) 4797 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4798 // int -> Dimensions map 4799 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4800 // int -> FLOAT32 map 4801 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 4802 // int -> INT32 map 4803 .int32Operands = {}, 4804 // int -> QUANT8_ASYMM map 4805 .quant8AsymmOperands = {}, 4806 // int -> QUANT16_SYMM map 4807 .quant16SymmOperands = {}, 4808 // int -> FLOAT16 map 4809 .float16Operands = {}, 4810 // int -> BOOL8 map 4811 .bool8Operands = {}, 4812 // int -> QUANT8_SYMM_PER_CHANNEL map 4813 .quant8ChannelOperands = {}, 4814 // int -> QUANT16_ASYMM map 4815 .quant16AsymmOperands = {}, 4816 // int -> QUANT8_SYMM map 4817 .quant8SymmOperands = {}, 4818 }, 4819 //Output(s) 4820 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4821 // int -> Dimensions map 4822 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4823 // int -> FLOAT32 map 4824 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 4825 // int -> INT32 map 4826 .int32Operands = {}, 4827 // int -> QUANT8_ASYMM map 4828 .quant8AsymmOperands = {}, 4829 // int -> QUANT16_SYMM map 4830 .quant16SymmOperands = {}, 4831 // int -> FLOAT16 map 4832 .float16Operands = {}, 4833 // int -> BOOL8 map 4834 .bool8Operands = {}, 4835 // int -> QUANT8_SYMM_PER_CHANNEL map 4836 .quant8ChannelOperands = {}, 4837 // int -> QUANT16_ASYMM map 4838 .quant16AsymmOperands = {}, 4839 // int -> QUANT8_SYMM map 4840 .quant8SymmOperands = {}, 4841 } 4842 }, 4843 }, // End of an example 4844 }; 4845 return examples_nchw_relu1; 4846 }; 4847 4848 std::vector<MixedTypedExample>& get_examples_nchw_relu1_weight_as_input() { 4849 static std::vector<MixedTypedExample> examples_nchw_relu1_weight_as_input = { 4850 // Begin of an example 4851 { 4852 .operands = { 4853 //Input(s) 4854 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4855 // int -> Dimensions map 4856 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4857 // int -> FLOAT32 map 4858 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 2, 5, 5}}}, 4880 // int -> FLOAT32 map 4881 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 4882 // int -> INT32 map 4883 .int32Operands = {}, 4884 // int -> QUANT8_ASYMM map 4885 .quant8AsymmOperands = {}, 4886 // int -> QUANT16_SYMM map 4887 .quant16SymmOperands = {}, 4888 // int -> FLOAT16 map 4889 .float16Operands = {}, 4890 // int -> BOOL8 map 4891 .bool8Operands = {}, 4892 // int -> QUANT8_SYMM_PER_CHANNEL map 4893 .quant8ChannelOperands = {}, 4894 // int -> QUANT16_ASYMM map 4895 .quant16AsymmOperands = {}, 4896 // int -> QUANT8_SYMM map 4897 .quant8SymmOperands = {}, 4898 } 4899 }, 4900 }, // End of an example 4901 }; 4902 return examples_nchw_relu1_weight_as_input; 4903 }; 4904 4905 std::vector<MixedTypedExample>& get_examples_nchw_relu1_relaxed() { 4906 static std::vector<MixedTypedExample> examples_nchw_relu1_relaxed = { 4907 // Begin of an example 4908 { 4909 .operands = { 4910 //Input(s) 4911 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4912 // int -> Dimensions map 4913 .operandDimensions = {{0, {1, 1, 2, 2}}}, 4914 // int -> FLOAT32 map 4915 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 4916 // int -> INT32 map 4917 .int32Operands = {}, 4918 // int -> QUANT8_ASYMM map 4919 .quant8AsymmOperands = {}, 4920 // int -> QUANT16_SYMM map 4921 .quant16SymmOperands = {}, 4922 // int -> FLOAT16 map 4923 .float16Operands = {}, 4924 // int -> BOOL8 map 4925 .bool8Operands = {}, 4926 // int -> QUANT8_SYMM_PER_CHANNEL map 4927 .quant8ChannelOperands = {}, 4928 // int -> QUANT16_ASYMM map 4929 .quant16AsymmOperands = {}, 4930 // int -> QUANT8_SYMM map 4931 .quant8SymmOperands = {}, 4932 }, 4933 //Output(s) 4934 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4935 // int -> Dimensions map 4936 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4937 // int -> FLOAT32 map 4938 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 4939 // int -> INT32 map 4940 .int32Operands = {}, 4941 // int -> QUANT8_ASYMM map 4942 .quant8AsymmOperands = {}, 4943 // int -> QUANT16_SYMM map 4944 .quant16SymmOperands = {}, 4945 // int -> FLOAT16 map 4946 .float16Operands = {}, 4947 // int -> BOOL8 map 4948 .bool8Operands = {}, 4949 // int -> QUANT8_SYMM_PER_CHANNEL map 4950 .quant8ChannelOperands = {}, 4951 // int -> QUANT16_ASYMM map 4952 .quant16AsymmOperands = {}, 4953 // int -> QUANT8_SYMM map 4954 .quant8SymmOperands = {}, 4955 } 4956 }, 4957 }, // End of an example 4958 }; 4959 return examples_nchw_relu1_relaxed; 4960 }; 4961 4962 std::vector<MixedTypedExample>& get_examples_nchw_relu1_relaxed_weight_as_input() { 4963 static std::vector<MixedTypedExample> examples_nchw_relu1_relaxed_weight_as_input = { 4964 // Begin of an example 4965 { 4966 .operands = { 4967 //Input(s) 4968 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4969 // int -> Dimensions map 4970 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 4971 // int -> FLOAT32 map 4972 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 4973 // int -> INT32 map 4974 .int32Operands = {}, 4975 // int -> QUANT8_ASYMM map 4976 .quant8AsymmOperands = {}, 4977 // int -> QUANT16_SYMM map 4978 .quant16SymmOperands = {}, 4979 // int -> FLOAT16 map 4980 .float16Operands = {}, 4981 // int -> BOOL8 map 4982 .bool8Operands = {}, 4983 // int -> QUANT8_SYMM_PER_CHANNEL map 4984 .quant8ChannelOperands = {}, 4985 // int -> QUANT16_ASYMM map 4986 .quant16AsymmOperands = {}, 4987 // int -> QUANT8_SYMM map 4988 .quant8SymmOperands = {}, 4989 }, 4990 //Output(s) 4991 { // See tools/test_generator/include/TestHarness.h:MixedTyped 4992 // int -> Dimensions map 4993 .operandDimensions = {{0, {1, 2, 5, 5}}}, 4994 // int -> FLOAT32 map 4995 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 4996 // int -> INT32 map 4997 .int32Operands = {}, 4998 // int -> QUANT8_ASYMM map 4999 .quant8AsymmOperands = {}, 5000 // int -> QUANT16_SYMM map 5001 .quant16SymmOperands = {}, 5002 // int -> FLOAT16 map 5003 .float16Operands = {}, 5004 // int -> BOOL8 map 5005 .bool8Operands = {}, 5006 // int -> QUANT8_SYMM_PER_CHANNEL map 5007 .quant8ChannelOperands = {}, 5008 // int -> QUANT16_ASYMM map 5009 .quant16AsymmOperands = {}, 5010 // int -> QUANT8_SYMM map 5011 .quant8SymmOperands = {}, 5012 } 5013 }, 5014 }, // End of an example 5015 }; 5016 return examples_nchw_relu1_relaxed_weight_as_input; 5017 }; 5018 5019 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8() { 5020 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8 = { 5021 // Begin of an example 5022 { 5023 .operands = { 5024 //Input(s) 5025 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5026 // int -> Dimensions map 5027 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5028 // int -> FLOAT32 map 5029 .float32Operands = {}, 5030 // int -> INT32 map 5031 .int32Operands = {}, 5032 // int -> QUANT8_ASYMM map 5033 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 5034 // int -> QUANT16_SYMM map 5035 .quant16SymmOperands = {}, 5036 // int -> FLOAT16 map 5037 .float16Operands = {}, 5038 // int -> BOOL8 map 5039 .bool8Operands = {}, 5040 // int -> QUANT8_SYMM_PER_CHANNEL map 5041 .quant8ChannelOperands = {}, 5042 // int -> QUANT16_ASYMM map 5043 .quant16AsymmOperands = {}, 5044 // int -> QUANT8_SYMM map 5045 .quant8SymmOperands = {}, 5046 }, 5047 //Output(s) 5048 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5049 // int -> Dimensions map 5050 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5051 // int -> FLOAT32 map 5052 .float32Operands = {}, 5053 // int -> INT32 map 5054 .int32Operands = {}, 5055 // int -> QUANT8_ASYMM map 5056 .quant8AsymmOperands = {{0, {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 5057 // int -> QUANT16_SYMM map 5058 .quant16SymmOperands = {}, 5059 // int -> FLOAT16 map 5060 .float16Operands = {}, 5061 // int -> BOOL8 map 5062 .bool8Operands = {}, 5063 // int -> QUANT8_SYMM_PER_CHANNEL map 5064 .quant8ChannelOperands = {}, 5065 // int -> QUANT16_ASYMM map 5066 .quant16AsymmOperands = {}, 5067 // int -> QUANT8_SYMM map 5068 .quant8SymmOperands = {}, 5069 } 5070 }, 5071 }, // End of an example 5072 }; 5073 return examples_nchw_relu1_quant8; 5074 }; 5075 5076 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_weight_as_input() { 5077 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8_weight_as_input = { 5078 // Begin of an example 5079 { 5080 .operands = { 5081 //Input(s) 5082 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5083 // int -> Dimensions map 5084 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5085 // int -> FLOAT32 map 5086 .float32Operands = {}, 5087 // int -> INT32 map 5088 .int32Operands = {{2, {-6, -8}}}, 5089 // int -> QUANT8_ASYMM map 5090 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 5091 // int -> QUANT16_SYMM map 5092 .quant16SymmOperands = {}, 5093 // int -> FLOAT16 map 5094 .float16Operands = {}, 5095 // int -> BOOL8 map 5096 .bool8Operands = {}, 5097 // int -> QUANT8_SYMM_PER_CHANNEL map 5098 .quant8ChannelOperands = {}, 5099 // int -> QUANT16_ASYMM map 5100 .quant16AsymmOperands = {}, 5101 // int -> QUANT8_SYMM map 5102 .quant8SymmOperands = {}, 5103 }, 5104 //Output(s) 5105 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5106 // int -> Dimensions map 5107 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5108 // int -> FLOAT32 map 5109 .float32Operands = {}, 5110 // int -> INT32 map 5111 .int32Operands = {}, 5112 // int -> QUANT8_ASYMM map 5113 .quant8AsymmOperands = {{0, {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 5114 // int -> QUANT16_SYMM map 5115 .quant16SymmOperands = {}, 5116 // int -> FLOAT16 map 5117 .float16Operands = {}, 5118 // int -> BOOL8 map 5119 .bool8Operands = {}, 5120 // int -> QUANT8_SYMM_PER_CHANNEL map 5121 .quant8ChannelOperands = {}, 5122 // int -> QUANT16_ASYMM map 5123 .quant16AsymmOperands = {}, 5124 // int -> QUANT8_SYMM map 5125 .quant8SymmOperands = {}, 5126 } 5127 }, 5128 }, // End of an example 5129 }; 5130 return examples_nchw_relu1_quant8_weight_as_input; 5131 }; 5132 5133 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_2() { 5134 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8_2 = { 5135 // Begin of an example 5136 { 5137 .operands = { 5138 //Input(s) 5139 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5140 // int -> Dimensions map 5141 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5142 // int -> FLOAT32 map 5143 .float32Operands = {}, 5144 // int -> INT32 map 5145 .int32Operands = {}, 5146 // int -> QUANT8_ASYMM map 5147 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 5148 // int -> QUANT16_SYMM map 5149 .quant16SymmOperands = {}, 5150 // int -> FLOAT16 map 5151 .float16Operands = {}, 5152 // int -> BOOL8 map 5153 .bool8Operands = {}, 5154 // int -> QUANT8_SYMM_PER_CHANNEL map 5155 .quant8ChannelOperands = {}, 5156 // int -> QUANT16_ASYMM map 5157 .quant16AsymmOperands = {}, 5158 // int -> QUANT8_SYMM map 5159 .quant8SymmOperands = {}, 5160 }, 5161 //Output(s) 5162 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5163 // int -> Dimensions map 5164 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5165 // int -> FLOAT32 map 5166 .float32Operands = {}, 5167 // int -> INT32 map 5168 .int32Operands = {}, 5169 // int -> QUANT8_ASYMM map 5170 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 5171 // int -> QUANT16_SYMM map 5172 .quant16SymmOperands = {}, 5173 // int -> FLOAT16 map 5174 .float16Operands = {}, 5175 // int -> BOOL8 map 5176 .bool8Operands = {}, 5177 // int -> QUANT8_SYMM_PER_CHANNEL map 5178 .quant8ChannelOperands = {}, 5179 // int -> QUANT16_ASYMM map 5180 .quant16AsymmOperands = {}, 5181 // int -> QUANT8_SYMM map 5182 .quant8SymmOperands = {}, 5183 } 5184 }, 5185 }, // End of an example 5186 }; 5187 return examples_nchw_relu1_quant8_2; 5188 }; 5189 5190 std::vector<MixedTypedExample>& get_examples_nchw_relu1_quant8_weight_as_input_2() { 5191 static std::vector<MixedTypedExample> examples_nchw_relu1_quant8_weight_as_input_2 = { 5192 // Begin of an example 5193 { 5194 .operands = { 5195 //Input(s) 5196 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5197 // int -> Dimensions map 5198 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5199 // int -> FLOAT32 map 5200 .float32Operands = {}, 5201 // int -> INT32 map 5202 .int32Operands = {{2, {-6, -8}}}, 5203 // int -> QUANT8_ASYMM map 5204 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 5205 // int -> QUANT16_SYMM map 5206 .quant16SymmOperands = {}, 5207 // int -> FLOAT16 map 5208 .float16Operands = {}, 5209 // int -> BOOL8 map 5210 .bool8Operands = {}, 5211 // int -> QUANT8_SYMM_PER_CHANNEL map 5212 .quant8ChannelOperands = {}, 5213 // int -> QUANT16_ASYMM map 5214 .quant16AsymmOperands = {}, 5215 // int -> QUANT8_SYMM map 5216 .quant8SymmOperands = {}, 5217 }, 5218 //Output(s) 5219 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5220 // int -> Dimensions map 5221 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5222 // int -> FLOAT32 map 5223 .float32Operands = {}, 5224 // int -> INT32 map 5225 .int32Operands = {}, 5226 // int -> QUANT8_ASYMM map 5227 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 5228 // int -> QUANT16_SYMM map 5229 .quant16SymmOperands = {}, 5230 // int -> FLOAT16 map 5231 .float16Operands = {}, 5232 // int -> BOOL8 map 5233 .bool8Operands = {}, 5234 // int -> QUANT8_SYMM_PER_CHANNEL map 5235 .quant8ChannelOperands = {}, 5236 // int -> QUANT16_ASYMM map 5237 .quant16AsymmOperands = {}, 5238 // int -> QUANT8_SYMM map 5239 .quant8SymmOperands = {}, 5240 } 5241 }, 5242 }, // End of an example 5243 }; 5244 return examples_nchw_relu1_quant8_weight_as_input_2; 5245 }; 5246 5247 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8() { 5248 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8 = { 5249 // Begin of an example 5250 { 5251 .operands = { 5252 //Input(s) 5253 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5254 // int -> Dimensions map 5255 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5256 // int -> FLOAT32 map 5257 .float32Operands = {}, 5258 // int -> INT32 map 5259 .int32Operands = {}, 5260 // int -> QUANT8_ASYMM map 5261 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 5262 // int -> QUANT16_SYMM map 5263 .quant16SymmOperands = {}, 5264 // int -> FLOAT16 map 5265 .float16Operands = {}, 5266 // int -> BOOL8 map 5267 .bool8Operands = {}, 5268 // int -> QUANT8_SYMM_PER_CHANNEL map 5269 .quant8ChannelOperands = {}, 5270 // int -> QUANT16_ASYMM map 5271 .quant16AsymmOperands = {}, 5272 // int -> QUANT8_SYMM map 5273 .quant8SymmOperands = {}, 5274 }, 5275 //Output(s) 5276 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5277 // int -> Dimensions map 5278 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5279 // int -> FLOAT32 map 5280 .float32Operands = {}, 5281 // int -> INT32 map 5282 .int32Operands = {}, 5283 // int -> QUANT8_ASYMM map 5284 .quant8AsymmOperands = {{0, {79, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 5285 // int -> QUANT16_SYMM map 5286 .quant16SymmOperands = {}, 5287 // int -> FLOAT16 map 5288 .float16Operands = {}, 5289 // int -> BOOL8 map 5290 .bool8Operands = {}, 5291 // int -> QUANT8_SYMM_PER_CHANNEL map 5292 .quant8ChannelOperands = {}, 5293 // int -> QUANT16_ASYMM map 5294 .quant16AsymmOperands = {}, 5295 // int -> QUANT8_SYMM map 5296 .quant8SymmOperands = {}, 5297 } 5298 }, 5299 }, // End of an example 5300 }; 5301 return examples_nchw_relu1_channelQuant8; 5302 }; 5303 5304 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_weight_as_input() { 5305 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_weight_as_input = { 5306 // Begin of an example 5307 { 5308 .operands = { 5309 //Input(s) 5310 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5311 // int -> Dimensions map 5312 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5313 // int -> FLOAT32 map 5314 .float32Operands = {}, 5315 // int -> INT32 map 5316 .int32Operands = {{2, {-24, -16}}}, 5317 // int -> QUANT8_ASYMM map 5318 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 5319 // int -> QUANT16_SYMM map 5320 .quant16SymmOperands = {}, 5321 // int -> FLOAT16 map 5322 .float16Operands = {}, 5323 // int -> BOOL8 map 5324 .bool8Operands = {}, 5325 // int -> QUANT8_SYMM_PER_CHANNEL map 5326 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 5327 // int -> QUANT16_ASYMM map 5328 .quant16AsymmOperands = {}, 5329 // int -> QUANT8_SYMM map 5330 .quant8SymmOperands = {}, 5331 }, 5332 //Output(s) 5333 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5334 // int -> Dimensions map 5335 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5336 // int -> FLOAT32 map 5337 .float32Operands = {}, 5338 // int -> INT32 map 5339 .int32Operands = {}, 5340 // int -> QUANT8_ASYMM map 5341 .quant8AsymmOperands = {{0, {79, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 5342 // int -> QUANT16_SYMM map 5343 .quant16SymmOperands = {}, 5344 // int -> FLOAT16 map 5345 .float16Operands = {}, 5346 // int -> BOOL8 map 5347 .bool8Operands = {}, 5348 // int -> QUANT8_SYMM_PER_CHANNEL map 5349 .quant8ChannelOperands = {}, 5350 // int -> QUANT16_ASYMM map 5351 .quant16AsymmOperands = {}, 5352 // int -> QUANT8_SYMM map 5353 .quant8SymmOperands = {}, 5354 } 5355 }, 5356 }, // End of an example 5357 }; 5358 return examples_nchw_relu1_channelQuant8_weight_as_input; 5359 }; 5360 5361 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_2() { 5362 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_2 = { 5363 // Begin of an example 5364 { 5365 .operands = { 5366 //Input(s) 5367 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5368 // int -> Dimensions map 5369 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5370 // int -> FLOAT32 map 5371 .float32Operands = {}, 5372 // int -> INT32 map 5373 .int32Operands = {}, 5374 // int -> QUANT8_ASYMM map 5375 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 5376 // int -> QUANT16_SYMM map 5377 .quant16SymmOperands = {}, 5378 // int -> FLOAT16 map 5379 .float16Operands = {}, 5380 // int -> BOOL8 map 5381 .bool8Operands = {}, 5382 // int -> QUANT8_SYMM_PER_CHANNEL map 5383 .quant8ChannelOperands = {}, 5384 // int -> QUANT16_ASYMM map 5385 .quant16AsymmOperands = {}, 5386 // int -> QUANT8_SYMM map 5387 .quant8SymmOperands = {}, 5388 }, 5389 //Output(s) 5390 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5391 // int -> Dimensions map 5392 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5393 // int -> FLOAT32 map 5394 .float32Operands = {}, 5395 // int -> INT32 map 5396 .int32Operands = {}, 5397 // int -> QUANT8_ASYMM map 5398 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 5399 // int -> QUANT16_SYMM map 5400 .quant16SymmOperands = {}, 5401 // int -> FLOAT16 map 5402 .float16Operands = {}, 5403 // int -> BOOL8 map 5404 .bool8Operands = {}, 5405 // int -> QUANT8_SYMM_PER_CHANNEL map 5406 .quant8ChannelOperands = {}, 5407 // int -> QUANT16_ASYMM map 5408 .quant16AsymmOperands = {}, 5409 // int -> QUANT8_SYMM map 5410 .quant8SymmOperands = {}, 5411 } 5412 }, 5413 }, // End of an example 5414 }; 5415 return examples_nchw_relu1_channelQuant8_2; 5416 }; 5417 5418 std::vector<MixedTypedExample>& get_examples_nchw_relu1_channelQuant8_weight_as_input_2() { 5419 static std::vector<MixedTypedExample> examples_nchw_relu1_channelQuant8_weight_as_input_2 = { 5420 // Begin of an example 5421 { 5422 .operands = { 5423 //Input(s) 5424 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5425 // int -> Dimensions map 5426 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5427 // int -> FLOAT32 map 5428 .float32Operands = {}, 5429 // int -> INT32 map 5430 .int32Operands = {{2, {-24, -16}}}, 5431 // int -> QUANT8_ASYMM map 5432 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 5433 // int -> QUANT16_SYMM map 5434 .quant16SymmOperands = {}, 5435 // int -> FLOAT16 map 5436 .float16Operands = {}, 5437 // int -> BOOL8 map 5438 .bool8Operands = {}, 5439 // int -> QUANT8_SYMM_PER_CHANNEL map 5440 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 5441 // int -> QUANT16_ASYMM map 5442 .quant16AsymmOperands = {}, 5443 // int -> QUANT8_SYMM map 5444 .quant8SymmOperands = {}, 5445 }, 5446 //Output(s) 5447 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5448 // int -> Dimensions map 5449 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5450 // int -> FLOAT32 map 5451 .float32Operands = {}, 5452 // int -> INT32 map 5453 .int32Operands = {}, 5454 // int -> QUANT8_ASYMM map 5455 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 5456 // int -> QUANT16_SYMM map 5457 .quant16SymmOperands = {}, 5458 // int -> FLOAT16 map 5459 .float16Operands = {}, 5460 // int -> BOOL8 map 5461 .bool8Operands = {}, 5462 // int -> QUANT8_SYMM_PER_CHANNEL map 5463 .quant8ChannelOperands = {}, 5464 // int -> QUANT16_ASYMM map 5465 .quant16AsymmOperands = {}, 5466 // int -> QUANT8_SYMM map 5467 .quant8SymmOperands = {}, 5468 } 5469 }, 5470 }, // End of an example 5471 }; 5472 return examples_nchw_relu1_channelQuant8_weight_as_input_2; 5473 }; 5474 5475 std::vector<MixedTypedExample>& get_examples_nchw_relu1_float16() { 5476 static std::vector<MixedTypedExample> examples_nchw_relu1_float16 = { 5477 // Begin of an example 5478 { 5479 .operands = { 5480 //Input(s) 5481 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5482 // int -> Dimensions map 5483 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5484 // int -> FLOAT32 map 5485 .float32Operands = {}, 5486 // int -> INT32 map 5487 .int32Operands = {}, 5488 // int -> QUANT8_ASYMM map 5489 .quant8AsymmOperands = {}, 5490 // int -> QUANT16_SYMM map 5491 .quant16SymmOperands = {}, 5492 // int -> FLOAT16 map 5493 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 5494 // int -> BOOL8 map 5495 .bool8Operands = {}, 5496 // int -> QUANT8_SYMM_PER_CHANNEL map 5497 .quant8ChannelOperands = {}, 5498 // int -> QUANT16_ASYMM map 5499 .quant16AsymmOperands = {}, 5500 // int -> QUANT8_SYMM map 5501 .quant8SymmOperands = {}, 5502 }, 5503 //Output(s) 5504 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5505 // int -> Dimensions map 5506 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5507 // int -> FLOAT32 map 5508 .float32Operands = {}, 5509 // int -> INT32 map 5510 .int32Operands = {}, 5511 // int -> QUANT8_ASYMM map 5512 .quant8AsymmOperands = {}, 5513 // int -> QUANT16_SYMM map 5514 .quant16SymmOperands = {}, 5515 // int -> FLOAT16 map 5516 .float16Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 5517 // int -> BOOL8 map 5518 .bool8Operands = {}, 5519 // int -> QUANT8_SYMM_PER_CHANNEL map 5520 .quant8ChannelOperands = {}, 5521 // int -> QUANT16_ASYMM map 5522 .quant16AsymmOperands = {}, 5523 // int -> QUANT8_SYMM map 5524 .quant8SymmOperands = {}, 5525 } 5526 }, 5527 }, // End of an example 5528 }; 5529 return examples_nchw_relu1_float16; 5530 }; 5531 5532 std::vector<MixedTypedExample>& get_examples_nchw_relu1_float16_weight_as_input() { 5533 static std::vector<MixedTypedExample> examples_nchw_relu1_float16_weight_as_input = { 5534 // Begin of an example 5535 { 5536 .operands = { 5537 //Input(s) 5538 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5539 // int -> Dimensions map 5540 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5541 // int -> FLOAT32 map 5542 .float32Operands = {}, 5543 // int -> INT32 map 5544 .int32Operands = {}, 5545 // int -> QUANT8_ASYMM map 5546 .quant8AsymmOperands = {}, 5547 // int -> QUANT16_SYMM map 5548 .quant16SymmOperands = {}, 5549 // int -> FLOAT16 map 5550 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 5551 // int -> BOOL8 map 5552 .bool8Operands = {}, 5553 // int -> QUANT8_SYMM_PER_CHANNEL map 5554 .quant8ChannelOperands = {}, 5555 // int -> QUANT16_ASYMM map 5556 .quant16AsymmOperands = {}, 5557 // int -> QUANT8_SYMM map 5558 .quant8SymmOperands = {}, 5559 }, 5560 //Output(s) 5561 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5562 // int -> Dimensions map 5563 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5564 // int -> FLOAT32 map 5565 .float32Operands = {}, 5566 // int -> INT32 map 5567 .int32Operands = {}, 5568 // int -> QUANT8_ASYMM map 5569 .quant8AsymmOperands = {}, 5570 // int -> QUANT16_SYMM map 5571 .quant16SymmOperands = {}, 5572 // int -> FLOAT16 map 5573 .float16Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 5574 // int -> BOOL8 map 5575 .bool8Operands = {}, 5576 // int -> QUANT8_SYMM_PER_CHANNEL map 5577 .quant8ChannelOperands = {}, 5578 // int -> QUANT16_ASYMM map 5579 .quant16AsymmOperands = {}, 5580 // int -> QUANT8_SYMM map 5581 .quant8SymmOperands = {}, 5582 } 5583 }, 5584 }, // End of an example 5585 }; 5586 return examples_nchw_relu1_float16_weight_as_input; 5587 }; 5588 5589 std::vector<MixedTypedExample>& get_examples_nchw_relu6() { 5590 static std::vector<MixedTypedExample> examples_nchw_relu6 = { 5591 // Begin of an example 5592 { 5593 .operands = { 5594 //Input(s) 5595 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5596 // int -> Dimensions map 5597 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5598 // int -> FLOAT32 map 5599 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 5600 // int -> INT32 map 5601 .int32Operands = {}, 5602 // int -> QUANT8_ASYMM map 5603 .quant8AsymmOperands = {}, 5604 // int -> QUANT16_SYMM map 5605 .quant16SymmOperands = {}, 5606 // int -> FLOAT16 map 5607 .float16Operands = {}, 5608 // int -> BOOL8 map 5609 .bool8Operands = {}, 5610 // int -> QUANT8_SYMM_PER_CHANNEL map 5611 .quant8ChannelOperands = {}, 5612 // int -> QUANT16_ASYMM map 5613 .quant16AsymmOperands = {}, 5614 // int -> QUANT8_SYMM map 5615 .quant8SymmOperands = {}, 5616 }, 5617 //Output(s) 5618 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5619 // int -> Dimensions map 5620 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5621 // int -> FLOAT32 map 5622 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 5623 // int -> INT32 map 5624 .int32Operands = {}, 5625 // int -> QUANT8_ASYMM map 5626 .quant8AsymmOperands = {}, 5627 // int -> QUANT16_SYMM map 5628 .quant16SymmOperands = {}, 5629 // int -> FLOAT16 map 5630 .float16Operands = {}, 5631 // int -> BOOL8 map 5632 .bool8Operands = {}, 5633 // int -> QUANT8_SYMM_PER_CHANNEL map 5634 .quant8ChannelOperands = {}, 5635 // int -> QUANT16_ASYMM map 5636 .quant16AsymmOperands = {}, 5637 // int -> QUANT8_SYMM map 5638 .quant8SymmOperands = {}, 5639 } 5640 }, 5641 }, // End of an example 5642 }; 5643 return examples_nchw_relu6; 5644 }; 5645 5646 std::vector<MixedTypedExample>& get_examples_nchw_relu6_weight_as_input() { 5647 static std::vector<MixedTypedExample> examples_nchw_relu6_weight_as_input = { 5648 // Begin of an example 5649 { 5650 .operands = { 5651 //Input(s) 5652 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5653 // int -> Dimensions map 5654 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5655 // int -> FLOAT32 map 5656 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 5657 // int -> INT32 map 5658 .int32Operands = {}, 5659 // int -> QUANT8_ASYMM map 5660 .quant8AsymmOperands = {}, 5661 // int -> QUANT16_SYMM map 5662 .quant16SymmOperands = {}, 5663 // int -> FLOAT16 map 5664 .float16Operands = {}, 5665 // int -> BOOL8 map 5666 .bool8Operands = {}, 5667 // int -> QUANT8_SYMM_PER_CHANNEL map 5668 .quant8ChannelOperands = {}, 5669 // int -> QUANT16_ASYMM map 5670 .quant16AsymmOperands = {}, 5671 // int -> QUANT8_SYMM map 5672 .quant8SymmOperands = {}, 5673 }, 5674 //Output(s) 5675 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5676 // int -> Dimensions map 5677 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5678 // int -> FLOAT32 map 5679 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 5680 // int -> INT32 map 5681 .int32Operands = {}, 5682 // int -> QUANT8_ASYMM map 5683 .quant8AsymmOperands = {}, 5684 // int -> QUANT16_SYMM map 5685 .quant16SymmOperands = {}, 5686 // int -> FLOAT16 map 5687 .float16Operands = {}, 5688 // int -> BOOL8 map 5689 .bool8Operands = {}, 5690 // int -> QUANT8_SYMM_PER_CHANNEL map 5691 .quant8ChannelOperands = {}, 5692 // int -> QUANT16_ASYMM map 5693 .quant16AsymmOperands = {}, 5694 // int -> QUANT8_SYMM map 5695 .quant8SymmOperands = {}, 5696 } 5697 }, 5698 }, // End of an example 5699 }; 5700 return examples_nchw_relu6_weight_as_input; 5701 }; 5702 5703 std::vector<MixedTypedExample>& get_examples_nchw_relu6_relaxed() { 5704 static std::vector<MixedTypedExample> examples_nchw_relu6_relaxed = { 5705 // Begin of an example 5706 { 5707 .operands = { 5708 //Input(s) 5709 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5710 // int -> Dimensions map 5711 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5712 // int -> FLOAT32 map 5713 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 5714 // int -> INT32 map 5715 .int32Operands = {}, 5716 // int -> QUANT8_ASYMM map 5717 .quant8AsymmOperands = {}, 5718 // int -> QUANT16_SYMM map 5719 .quant16SymmOperands = {}, 5720 // int -> FLOAT16 map 5721 .float16Operands = {}, 5722 // int -> BOOL8 map 5723 .bool8Operands = {}, 5724 // int -> QUANT8_SYMM_PER_CHANNEL map 5725 .quant8ChannelOperands = {}, 5726 // int -> QUANT16_ASYMM map 5727 .quant16AsymmOperands = {}, 5728 // int -> QUANT8_SYMM map 5729 .quant8SymmOperands = {}, 5730 }, 5731 //Output(s) 5732 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5733 // int -> Dimensions map 5734 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5735 // int -> FLOAT32 map 5736 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 5737 // int -> INT32 map 5738 .int32Operands = {}, 5739 // int -> QUANT8_ASYMM map 5740 .quant8AsymmOperands = {}, 5741 // int -> QUANT16_SYMM map 5742 .quant16SymmOperands = {}, 5743 // int -> FLOAT16 map 5744 .float16Operands = {}, 5745 // int -> BOOL8 map 5746 .bool8Operands = {}, 5747 // int -> QUANT8_SYMM_PER_CHANNEL map 5748 .quant8ChannelOperands = {}, 5749 // int -> QUANT16_ASYMM map 5750 .quant16AsymmOperands = {}, 5751 // int -> QUANT8_SYMM map 5752 .quant8SymmOperands = {}, 5753 } 5754 }, 5755 }, // End of an example 5756 }; 5757 return examples_nchw_relu6_relaxed; 5758 }; 5759 5760 std::vector<MixedTypedExample>& get_examples_nchw_relu6_relaxed_weight_as_input() { 5761 static std::vector<MixedTypedExample> examples_nchw_relu6_relaxed_weight_as_input = { 5762 // Begin of an example 5763 { 5764 .operands = { 5765 //Input(s) 5766 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5767 // int -> Dimensions map 5768 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5769 // int -> FLOAT32 map 5770 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 2, 5, 5}}}, 5792 // int -> FLOAT32 map 5793 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 5794 // int -> INT32 map 5795 .int32Operands = {}, 5796 // int -> QUANT8_ASYMM map 5797 .quant8AsymmOperands = {}, 5798 // int -> QUANT16_SYMM map 5799 .quant16SymmOperands = {}, 5800 // int -> FLOAT16 map 5801 .float16Operands = {}, 5802 // int -> BOOL8 map 5803 .bool8Operands = {}, 5804 // int -> QUANT8_SYMM_PER_CHANNEL map 5805 .quant8ChannelOperands = {}, 5806 // int -> QUANT16_ASYMM map 5807 .quant16AsymmOperands = {}, 5808 // int -> QUANT8_SYMM map 5809 .quant8SymmOperands = {}, 5810 } 5811 }, 5812 }, // End of an example 5813 }; 5814 return examples_nchw_relu6_relaxed_weight_as_input; 5815 }; 5816 5817 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8() { 5818 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8 = { 5819 // Begin of an example 5820 { 5821 .operands = { 5822 //Input(s) 5823 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5824 // int -> Dimensions map 5825 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5826 // int -> FLOAT32 map 5827 .float32Operands = {}, 5828 // int -> INT32 map 5829 .int32Operands = {}, 5830 // int -> QUANT8_ASYMM map 5831 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 5832 // int -> QUANT16_SYMM map 5833 .quant16SymmOperands = {}, 5834 // int -> FLOAT16 map 5835 .float16Operands = {}, 5836 // int -> BOOL8 map 5837 .bool8Operands = {}, 5838 // int -> QUANT8_SYMM_PER_CHANNEL map 5839 .quant8ChannelOperands = {}, 5840 // int -> QUANT16_ASYMM map 5841 .quant16AsymmOperands = {}, 5842 // int -> QUANT8_SYMM map 5843 .quant8SymmOperands = {}, 5844 }, 5845 //Output(s) 5846 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5847 // int -> Dimensions map 5848 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5849 // int -> FLOAT32 map 5850 .float32Operands = {}, 5851 // int -> INT32 map 5852 .int32Operands = {}, 5853 // int -> QUANT8_ASYMM map 5854 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 5855 // int -> QUANT16_SYMM map 5856 .quant16SymmOperands = {}, 5857 // int -> FLOAT16 map 5858 .float16Operands = {}, 5859 // int -> BOOL8 map 5860 .bool8Operands = {}, 5861 // int -> QUANT8_SYMM_PER_CHANNEL map 5862 .quant8ChannelOperands = {}, 5863 // int -> QUANT16_ASYMM map 5864 .quant16AsymmOperands = {}, 5865 // int -> QUANT8_SYMM map 5866 .quant8SymmOperands = {}, 5867 } 5868 }, 5869 }, // End of an example 5870 }; 5871 return examples_nchw_relu6_quant8; 5872 }; 5873 5874 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_weight_as_input() { 5875 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_weight_as_input = { 5876 // Begin of an example 5877 { 5878 .operands = { 5879 //Input(s) 5880 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5881 // int -> Dimensions map 5882 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5883 // int -> FLOAT32 map 5884 .float32Operands = {}, 5885 // int -> INT32 map 5886 .int32Operands = {{2, {-6, -8}}}, 5887 // int -> QUANT8_ASYMM map 5888 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 5889 // int -> QUANT16_SYMM map 5890 .quant16SymmOperands = {}, 5891 // int -> FLOAT16 map 5892 .float16Operands = {}, 5893 // int -> BOOL8 map 5894 .bool8Operands = {}, 5895 // int -> QUANT8_SYMM_PER_CHANNEL map 5896 .quant8ChannelOperands = {}, 5897 // int -> QUANT16_ASYMM map 5898 .quant16AsymmOperands = {}, 5899 // int -> QUANT8_SYMM map 5900 .quant8SymmOperands = {}, 5901 }, 5902 //Output(s) 5903 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5904 // int -> Dimensions map 5905 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5906 // int -> FLOAT32 map 5907 .float32Operands = {}, 5908 // int -> INT32 map 5909 .int32Operands = {}, 5910 // int -> QUANT8_ASYMM map 5911 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 5912 // int -> QUANT16_SYMM map 5913 .quant16SymmOperands = {}, 5914 // int -> FLOAT16 map 5915 .float16Operands = {}, 5916 // int -> BOOL8 map 5917 .bool8Operands = {}, 5918 // int -> QUANT8_SYMM_PER_CHANNEL map 5919 .quant8ChannelOperands = {}, 5920 // int -> QUANT16_ASYMM map 5921 .quant16AsymmOperands = {}, 5922 // int -> QUANT8_SYMM map 5923 .quant8SymmOperands = {}, 5924 } 5925 }, 5926 }, // End of an example 5927 }; 5928 return examples_nchw_relu6_quant8_weight_as_input; 5929 }; 5930 5931 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_2() { 5932 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_2 = { 5933 // Begin of an example 5934 { 5935 .operands = { 5936 //Input(s) 5937 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5938 // int -> Dimensions map 5939 .operandDimensions = {{0, {1, 1, 2, 2}}}, 5940 // int -> FLOAT32 map 5941 .float32Operands = {}, 5942 // int -> INT32 map 5943 .int32Operands = {}, 5944 // int -> QUANT8_ASYMM map 5945 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 5946 // int -> QUANT16_SYMM map 5947 .quant16SymmOperands = {}, 5948 // int -> FLOAT16 map 5949 .float16Operands = {}, 5950 // int -> BOOL8 map 5951 .bool8Operands = {}, 5952 // int -> QUANT8_SYMM_PER_CHANNEL map 5953 .quant8ChannelOperands = {}, 5954 // int -> QUANT16_ASYMM map 5955 .quant16AsymmOperands = {}, 5956 // int -> QUANT8_SYMM map 5957 .quant8SymmOperands = {}, 5958 }, 5959 //Output(s) 5960 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5961 // int -> Dimensions map 5962 .operandDimensions = {{0, {1, 2, 5, 5}}}, 5963 // int -> FLOAT32 map 5964 .float32Operands = {}, 5965 // int -> INT32 map 5966 .int32Operands = {}, 5967 // int -> QUANT8_ASYMM map 5968 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 5969 // int -> QUANT16_SYMM map 5970 .quant16SymmOperands = {}, 5971 // int -> FLOAT16 map 5972 .float16Operands = {}, 5973 // int -> BOOL8 map 5974 .bool8Operands = {}, 5975 // int -> QUANT8_SYMM_PER_CHANNEL map 5976 .quant8ChannelOperands = {}, 5977 // int -> QUANT16_ASYMM map 5978 .quant16AsymmOperands = {}, 5979 // int -> QUANT8_SYMM map 5980 .quant8SymmOperands = {}, 5981 } 5982 }, 5983 }, // End of an example 5984 }; 5985 return examples_nchw_relu6_quant8_2; 5986 }; 5987 5988 std::vector<MixedTypedExample>& get_examples_nchw_relu6_quant8_weight_as_input_2() { 5989 static std::vector<MixedTypedExample> examples_nchw_relu6_quant8_weight_as_input_2 = { 5990 // Begin of an example 5991 { 5992 .operands = { 5993 //Input(s) 5994 { // See tools/test_generator/include/TestHarness.h:MixedTyped 5995 // int -> Dimensions map 5996 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 5997 // int -> FLOAT32 map 5998 .float32Operands = {}, 5999 // int -> INT32 map 6000 .int32Operands = {{2, {-6, -8}}}, 6001 // int -> QUANT8_ASYMM map 6002 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 6003 // int -> QUANT16_SYMM map 6004 .quant16SymmOperands = {}, 6005 // int -> FLOAT16 map 6006 .float16Operands = {}, 6007 // int -> BOOL8 map 6008 .bool8Operands = {}, 6009 // int -> QUANT8_SYMM_PER_CHANNEL map 6010 .quant8ChannelOperands = {}, 6011 // int -> QUANT16_ASYMM map 6012 .quant16AsymmOperands = {}, 6013 // int -> QUANT8_SYMM map 6014 .quant8SymmOperands = {}, 6015 }, 6016 //Output(s) 6017 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6018 // int -> Dimensions map 6019 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6020 // int -> FLOAT32 map 6021 .float32Operands = {}, 6022 // int -> INT32 map 6023 .int32Operands = {}, 6024 // int -> QUANT8_ASYMM map 6025 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 6026 // int -> QUANT16_SYMM map 6027 .quant16SymmOperands = {}, 6028 // int -> FLOAT16 map 6029 .float16Operands = {}, 6030 // int -> BOOL8 map 6031 .bool8Operands = {}, 6032 // int -> QUANT8_SYMM_PER_CHANNEL map 6033 .quant8ChannelOperands = {}, 6034 // int -> QUANT16_ASYMM map 6035 .quant16AsymmOperands = {}, 6036 // int -> QUANT8_SYMM map 6037 .quant8SymmOperands = {}, 6038 } 6039 }, 6040 }, // End of an example 6041 }; 6042 return examples_nchw_relu6_quant8_weight_as_input_2; 6043 }; 6044 6045 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8() { 6046 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8 = { 6047 // Begin of an example 6048 { 6049 .operands = { 6050 //Input(s) 6051 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6052 // int -> Dimensions map 6053 .operandDimensions = {{0, {1, 1, 2, 2}}}, 6054 // int -> FLOAT32 map 6055 .float32Operands = {}, 6056 // int -> INT32 map 6057 .int32Operands = {}, 6058 // int -> QUANT8_ASYMM map 6059 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6060 // int -> QUANT16_SYMM map 6061 .quant16SymmOperands = {}, 6062 // int -> FLOAT16 map 6063 .float16Operands = {}, 6064 // int -> BOOL8 map 6065 .bool8Operands = {}, 6066 // int -> QUANT8_SYMM_PER_CHANNEL map 6067 .quant8ChannelOperands = {}, 6068 // int -> QUANT16_ASYMM map 6069 .quant16AsymmOperands = {}, 6070 // int -> QUANT8_SYMM map 6071 .quant8SymmOperands = {}, 6072 }, 6073 //Output(s) 6074 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6075 // int -> Dimensions map 6076 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6077 // int -> FLOAT32 map 6078 .float32Operands = {}, 6079 // int -> INT32 map 6080 .int32Operands = {}, 6081 // int -> QUANT8_ASYMM map 6082 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 80, 84, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 6083 // int -> QUANT16_SYMM map 6084 .quant16SymmOperands = {}, 6085 // int -> FLOAT16 map 6086 .float16Operands = {}, 6087 // int -> BOOL8 map 6088 .bool8Operands = {}, 6089 // int -> QUANT8_SYMM_PER_CHANNEL map 6090 .quant8ChannelOperands = {}, 6091 // int -> QUANT16_ASYMM map 6092 .quant16AsymmOperands = {}, 6093 // int -> QUANT8_SYMM map 6094 .quant8SymmOperands = {}, 6095 } 6096 }, 6097 }, // End of an example 6098 }; 6099 return examples_nchw_relu6_channelQuant8; 6100 }; 6101 6102 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_weight_as_input() { 6103 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_weight_as_input = { 6104 // Begin of an example 6105 { 6106 .operands = { 6107 //Input(s) 6108 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6109 // int -> Dimensions map 6110 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6111 // int -> FLOAT32 map 6112 .float32Operands = {}, 6113 // int -> INT32 map 6114 .int32Operands = {{2, {-24, -16}}}, 6115 // int -> QUANT8_ASYMM map 6116 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6117 // int -> QUANT16_SYMM map 6118 .quant16SymmOperands = {}, 6119 // int -> FLOAT16 map 6120 .float16Operands = {}, 6121 // int -> BOOL8 map 6122 .bool8Operands = {}, 6123 // int -> QUANT8_SYMM_PER_CHANNEL map 6124 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 6125 // int -> QUANT16_ASYMM map 6126 .quant16AsymmOperands = {}, 6127 // int -> QUANT8_SYMM map 6128 .quant8SymmOperands = {}, 6129 }, 6130 //Output(s) 6131 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6132 // int -> Dimensions map 6133 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6134 // int -> FLOAT32 map 6135 .float32Operands = {}, 6136 // int -> INT32 map 6137 .int32Operands = {}, 6138 // int -> QUANT8_ASYMM map 6139 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 80, 84, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 6140 // int -> QUANT16_SYMM map 6141 .quant16SymmOperands = {}, 6142 // int -> FLOAT16 map 6143 .float16Operands = {}, 6144 // int -> BOOL8 map 6145 .bool8Operands = {}, 6146 // int -> QUANT8_SYMM_PER_CHANNEL map 6147 .quant8ChannelOperands = {}, 6148 // int -> QUANT16_ASYMM map 6149 .quant16AsymmOperands = {}, 6150 // int -> QUANT8_SYMM map 6151 .quant8SymmOperands = {}, 6152 } 6153 }, 6154 }, // End of an example 6155 }; 6156 return examples_nchw_relu6_channelQuant8_weight_as_input; 6157 }; 6158 6159 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_2() { 6160 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_2 = { 6161 // Begin of an example 6162 { 6163 .operands = { 6164 //Input(s) 6165 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6166 // int -> Dimensions map 6167 .operandDimensions = {{0, {1, 1, 2, 2}}}, 6168 // int -> FLOAT32 map 6169 .float32Operands = {}, 6170 // int -> INT32 map 6171 .int32Operands = {}, 6172 // int -> QUANT8_ASYMM map 6173 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6174 // int -> QUANT16_SYMM map 6175 .quant16SymmOperands = {}, 6176 // int -> FLOAT16 map 6177 .float16Operands = {}, 6178 // int -> BOOL8 map 6179 .bool8Operands = {}, 6180 // int -> QUANT8_SYMM_PER_CHANNEL map 6181 .quant8ChannelOperands = {}, 6182 // int -> QUANT16_ASYMM map 6183 .quant16AsymmOperands = {}, 6184 // int -> QUANT8_SYMM map 6185 .quant8SymmOperands = {}, 6186 }, 6187 //Output(s) 6188 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6189 // int -> Dimensions map 6190 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6191 // int -> FLOAT32 map 6192 .float32Operands = {}, 6193 // int -> INT32 map 6194 .int32Operands = {}, 6195 // int -> QUANT8_ASYMM map 6196 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 6197 // int -> QUANT16_SYMM map 6198 .quant16SymmOperands = {}, 6199 // int -> FLOAT16 map 6200 .float16Operands = {}, 6201 // int -> BOOL8 map 6202 .bool8Operands = {}, 6203 // int -> QUANT8_SYMM_PER_CHANNEL map 6204 .quant8ChannelOperands = {}, 6205 // int -> QUANT16_ASYMM map 6206 .quant16AsymmOperands = {}, 6207 // int -> QUANT8_SYMM map 6208 .quant8SymmOperands = {}, 6209 } 6210 }, 6211 }, // End of an example 6212 }; 6213 return examples_nchw_relu6_channelQuant8_2; 6214 }; 6215 6216 std::vector<MixedTypedExample>& get_examples_nchw_relu6_channelQuant8_weight_as_input_2() { 6217 static std::vector<MixedTypedExample> examples_nchw_relu6_channelQuant8_weight_as_input_2 = { 6218 // Begin of an example 6219 { 6220 .operands = { 6221 //Input(s) 6222 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6223 // int -> Dimensions map 6224 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6225 // int -> FLOAT32 map 6226 .float32Operands = {}, 6227 // int -> INT32 map 6228 .int32Operands = {{2, {-24, -16}}}, 6229 // int -> QUANT8_ASYMM map 6230 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6231 // int -> QUANT16_SYMM map 6232 .quant16SymmOperands = {}, 6233 // int -> FLOAT16 map 6234 .float16Operands = {}, 6235 // int -> BOOL8 map 6236 .bool8Operands = {}, 6237 // int -> QUANT8_SYMM_PER_CHANNEL map 6238 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 6239 // int -> QUANT16_ASYMM map 6240 .quant16AsymmOperands = {}, 6241 // int -> QUANT8_SYMM map 6242 .quant8SymmOperands = {}, 6243 }, 6244 //Output(s) 6245 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6246 // int -> Dimensions map 6247 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6248 // int -> FLOAT32 map 6249 .float32Operands = {}, 6250 // int -> INT32 map 6251 .int32Operands = {}, 6252 // int -> QUANT8_ASYMM map 6253 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 6254 // int -> QUANT16_SYMM map 6255 .quant16SymmOperands = {}, 6256 // int -> FLOAT16 map 6257 .float16Operands = {}, 6258 // int -> BOOL8 map 6259 .bool8Operands = {}, 6260 // int -> QUANT8_SYMM_PER_CHANNEL map 6261 .quant8ChannelOperands = {}, 6262 // int -> QUANT16_ASYMM map 6263 .quant16AsymmOperands = {}, 6264 // int -> QUANT8_SYMM map 6265 .quant8SymmOperands = {}, 6266 } 6267 }, 6268 }, // End of an example 6269 }; 6270 return examples_nchw_relu6_channelQuant8_weight_as_input_2; 6271 }; 6272 6273 std::vector<MixedTypedExample>& get_examples_nchw_relu6_float16() { 6274 static std::vector<MixedTypedExample> examples_nchw_relu6_float16 = { 6275 // Begin of an example 6276 { 6277 .operands = { 6278 //Input(s) 6279 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6280 // int -> Dimensions map 6281 .operandDimensions = {{0, {1, 1, 2, 2}}}, 6282 // int -> FLOAT32 map 6283 .float32Operands = {}, 6284 // int -> INT32 map 6285 .int32Operands = {}, 6286 // int -> QUANT8_ASYMM map 6287 .quant8AsymmOperands = {}, 6288 // int -> QUANT16_SYMM map 6289 .quant16SymmOperands = {}, 6290 // int -> FLOAT16 map 6291 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 6292 // int -> BOOL8 map 6293 .bool8Operands = {}, 6294 // int -> QUANT8_SYMM_PER_CHANNEL map 6295 .quant8ChannelOperands = {}, 6296 // int -> QUANT16_ASYMM map 6297 .quant16AsymmOperands = {}, 6298 // int -> QUANT8_SYMM map 6299 .quant8SymmOperands = {}, 6300 }, 6301 //Output(s) 6302 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6303 // int -> Dimensions map 6304 .operandDimensions = {{0, {1, 2, 5, 5}}}, 6305 // int -> FLOAT32 map 6306 .float32Operands = {}, 6307 // int -> INT32 map 6308 .int32Operands = {}, 6309 // int -> QUANT8_ASYMM map 6310 .quant8AsymmOperands = {}, 6311 // int -> QUANT16_SYMM map 6312 .quant16SymmOperands = {}, 6313 // int -> FLOAT16 map 6314 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 6315 // int -> BOOL8 map 6316 .bool8Operands = {}, 6317 // int -> QUANT8_SYMM_PER_CHANNEL map 6318 .quant8ChannelOperands = {}, 6319 // int -> QUANT16_ASYMM map 6320 .quant16AsymmOperands = {}, 6321 // int -> QUANT8_SYMM map 6322 .quant8SymmOperands = {}, 6323 } 6324 }, 6325 }, // End of an example 6326 }; 6327 return examples_nchw_relu6_float16; 6328 }; 6329 6330 std::vector<MixedTypedExample>& get_examples_nchw_relu6_float16_weight_as_input() { 6331 static std::vector<MixedTypedExample> examples_nchw_relu6_float16_weight_as_input = { 6332 // Begin of an example 6333 { 6334 .operands = { 6335 //Input(s) 6336 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6337 // int -> Dimensions map 6338 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6339 // int -> FLOAT32 map 6340 .float32Operands = {}, 6341 // int -> INT32 map 6342 .int32Operands = {}, 6343 // int -> QUANT8_ASYMM map 6344 .quant8AsymmOperands = {}, 6345 // int -> QUANT16_SYMM map 6346 .quant16SymmOperands = {}, 6347 // int -> FLOAT16 map 6348 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.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, 2, 5, 5}}}, 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, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 6372 // int -> BOOL8 map 6373 .bool8Operands = {}, 6374 // int -> QUANT8_SYMM_PER_CHANNEL map 6375 .quant8ChannelOperands = {}, 6376 // int -> QUANT16_ASYMM map 6377 .quant16AsymmOperands = {}, 6378 // int -> QUANT8_SYMM map 6379 .quant8SymmOperands = {}, 6380 } 6381 }, 6382 }, // End of an example 6383 }; 6384 return examples_nchw_relu6_float16_weight_as_input; 6385 }; 6386 6387 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none() { 6388 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none = { 6389 // Begin of an example 6390 { 6391 .operands = { 6392 //Input(s) 6393 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6394 // int -> Dimensions map 6395 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6396 // int -> FLOAT32 map 6397 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 6398 // int -> INT32 map 6399 .int32Operands = {}, 6400 // int -> QUANT8_ASYMM map 6401 .quant8AsymmOperands = {}, 6402 // int -> QUANT16_SYMM map 6403 .quant16SymmOperands = {}, 6404 // int -> FLOAT16 map 6405 .float16Operands = {}, 6406 // int -> BOOL8 map 6407 .bool8Operands = {}, 6408 // int -> QUANT8_SYMM_PER_CHANNEL map 6409 .quant8ChannelOperands = {}, 6410 // int -> QUANT16_ASYMM map 6411 .quant16AsymmOperands = {}, 6412 // int -> QUANT8_SYMM map 6413 .quant8SymmOperands = {}, 6414 }, 6415 //Output(s) 6416 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6417 // int -> Dimensions map 6418 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6419 // int -> FLOAT32 map 6420 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 6421 // int -> INT32 map 6422 .int32Operands = {}, 6423 // int -> QUANT8_ASYMM map 6424 .quant8AsymmOperands = {}, 6425 // int -> QUANT16_SYMM map 6426 .quant16SymmOperands = {}, 6427 // int -> FLOAT16 map 6428 .float16Operands = {}, 6429 // int -> BOOL8 map 6430 .bool8Operands = {}, 6431 // int -> QUANT8_SYMM_PER_CHANNEL map 6432 .quant8ChannelOperands = {}, 6433 // int -> QUANT16_ASYMM map 6434 .quant16AsymmOperands = {}, 6435 // int -> QUANT8_SYMM map 6436 .quant8SymmOperands = {}, 6437 } 6438 }, 6439 }, // End of an example 6440 }; 6441 return examples_dynamic_output_shape_nhwc_none; 6442 }; 6443 6444 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_weight_as_input() { 6445 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_weight_as_input = { 6446 // Begin of an example 6447 { 6448 .operands = { 6449 //Input(s) 6450 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6451 // int -> Dimensions map 6452 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6453 // int -> FLOAT32 map 6454 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 6455 // int -> INT32 map 6456 .int32Operands = {}, 6457 // int -> QUANT8_ASYMM map 6458 .quant8AsymmOperands = {}, 6459 // int -> QUANT16_SYMM map 6460 .quant16SymmOperands = {}, 6461 // int -> FLOAT16 map 6462 .float16Operands = {}, 6463 // int -> BOOL8 map 6464 .bool8Operands = {}, 6465 // int -> QUANT8_SYMM_PER_CHANNEL map 6466 .quant8ChannelOperands = {}, 6467 // int -> QUANT16_ASYMM map 6468 .quant16AsymmOperands = {}, 6469 // int -> QUANT8_SYMM map 6470 .quant8SymmOperands = {}, 6471 }, 6472 //Output(s) 6473 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6474 // int -> Dimensions map 6475 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6476 // int -> FLOAT32 map 6477 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 6478 // int -> INT32 map 6479 .int32Operands = {}, 6480 // int -> QUANT8_ASYMM map 6481 .quant8AsymmOperands = {}, 6482 // int -> QUANT16_SYMM map 6483 .quant16SymmOperands = {}, 6484 // int -> FLOAT16 map 6485 .float16Operands = {}, 6486 // int -> BOOL8 map 6487 .bool8Operands = {}, 6488 // int -> QUANT8_SYMM_PER_CHANNEL map 6489 .quant8ChannelOperands = {}, 6490 // int -> QUANT16_ASYMM map 6491 .quant16AsymmOperands = {}, 6492 // int -> QUANT8_SYMM map 6493 .quant8SymmOperands = {}, 6494 } 6495 }, 6496 }, // End of an example 6497 }; 6498 return examples_dynamic_output_shape_nhwc_none_weight_as_input; 6499 }; 6500 6501 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_relaxed() { 6502 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_relaxed = { 6503 // Begin of an example 6504 { 6505 .operands = { 6506 //Input(s) 6507 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6508 // int -> Dimensions map 6509 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6510 // int -> FLOAT32 map 6511 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 6512 // int -> INT32 map 6513 .int32Operands = {}, 6514 // int -> QUANT8_ASYMM map 6515 .quant8AsymmOperands = {}, 6516 // int -> QUANT16_SYMM map 6517 .quant16SymmOperands = {}, 6518 // int -> FLOAT16 map 6519 .float16Operands = {}, 6520 // int -> BOOL8 map 6521 .bool8Operands = {}, 6522 // int -> QUANT8_SYMM_PER_CHANNEL map 6523 .quant8ChannelOperands = {}, 6524 // int -> QUANT16_ASYMM map 6525 .quant16AsymmOperands = {}, 6526 // int -> QUANT8_SYMM map 6527 .quant8SymmOperands = {}, 6528 }, 6529 //Output(s) 6530 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6531 // int -> Dimensions map 6532 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6533 // int -> FLOAT32 map 6534 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 6535 // int -> INT32 map 6536 .int32Operands = {}, 6537 // int -> QUANT8_ASYMM map 6538 .quant8AsymmOperands = {}, 6539 // int -> QUANT16_SYMM map 6540 .quant16SymmOperands = {}, 6541 // int -> FLOAT16 map 6542 .float16Operands = {}, 6543 // int -> BOOL8 map 6544 .bool8Operands = {}, 6545 // int -> QUANT8_SYMM_PER_CHANNEL map 6546 .quant8ChannelOperands = {}, 6547 // int -> QUANT16_ASYMM map 6548 .quant16AsymmOperands = {}, 6549 // int -> QUANT8_SYMM map 6550 .quant8SymmOperands = {}, 6551 } 6552 }, 6553 }, // End of an example 6554 }; 6555 return examples_dynamic_output_shape_nhwc_none_relaxed; 6556 }; 6557 6558 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input() { 6559 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input = { 6560 // Begin of an example 6561 { 6562 .operands = { 6563 //Input(s) 6564 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6565 // int -> Dimensions map 6566 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6567 // int -> FLOAT32 map 6568 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 6569 // int -> INT32 map 6570 .int32Operands = {}, 6571 // int -> QUANT8_ASYMM map 6572 .quant8AsymmOperands = {}, 6573 // int -> QUANT16_SYMM map 6574 .quant16SymmOperands = {}, 6575 // int -> FLOAT16 map 6576 .float16Operands = {}, 6577 // int -> BOOL8 map 6578 .bool8Operands = {}, 6579 // int -> QUANT8_SYMM_PER_CHANNEL map 6580 .quant8ChannelOperands = {}, 6581 // int -> QUANT16_ASYMM map 6582 .quant16AsymmOperands = {}, 6583 // int -> QUANT8_SYMM map 6584 .quant8SymmOperands = {}, 6585 }, 6586 //Output(s) 6587 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6588 // int -> Dimensions map 6589 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6590 // int -> FLOAT32 map 6591 .float32Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 6592 // int -> INT32 map 6593 .int32Operands = {}, 6594 // int -> QUANT8_ASYMM map 6595 .quant8AsymmOperands = {}, 6596 // int -> QUANT16_SYMM map 6597 .quant16SymmOperands = {}, 6598 // int -> FLOAT16 map 6599 .float16Operands = {}, 6600 // int -> BOOL8 map 6601 .bool8Operands = {}, 6602 // int -> QUANT8_SYMM_PER_CHANNEL map 6603 .quant8ChannelOperands = {}, 6604 // int -> QUANT16_ASYMM map 6605 .quant16AsymmOperands = {}, 6606 // int -> QUANT8_SYMM map 6607 .quant8SymmOperands = {}, 6608 } 6609 }, 6610 }, // End of an example 6611 }; 6612 return examples_dynamic_output_shape_nhwc_none_relaxed_weight_as_input; 6613 }; 6614 6615 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8() { 6616 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8 = { 6617 // Begin of an example 6618 { 6619 .operands = { 6620 //Input(s) 6621 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6622 // int -> Dimensions map 6623 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6624 // int -> FLOAT32 map 6625 .float32Operands = {}, 6626 // int -> INT32 map 6627 .int32Operands = {}, 6628 // int -> QUANT8_ASYMM map 6629 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 6630 // int -> QUANT16_SYMM map 6631 .quant16SymmOperands = {}, 6632 // int -> FLOAT16 map 6633 .float16Operands = {}, 6634 // int -> BOOL8 map 6635 .bool8Operands = {}, 6636 // int -> QUANT8_SYMM_PER_CHANNEL map 6637 .quant8ChannelOperands = {}, 6638 // int -> QUANT16_ASYMM map 6639 .quant16AsymmOperands = {}, 6640 // int -> QUANT8_SYMM map 6641 .quant8SymmOperands = {}, 6642 }, 6643 //Output(s) 6644 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6645 // int -> Dimensions map 6646 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6647 // int -> FLOAT32 map 6648 .float32Operands = {}, 6649 // int -> INT32 map 6650 .int32Operands = {}, 6651 // int -> QUANT8_ASYMM map 6652 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 6653 // int -> QUANT16_SYMM map 6654 .quant16SymmOperands = {}, 6655 // int -> FLOAT16 map 6656 .float16Operands = {}, 6657 // int -> BOOL8 map 6658 .bool8Operands = {}, 6659 // int -> QUANT8_SYMM_PER_CHANNEL map 6660 .quant8ChannelOperands = {}, 6661 // int -> QUANT16_ASYMM map 6662 .quant16AsymmOperands = {}, 6663 // int -> QUANT8_SYMM map 6664 .quant8SymmOperands = {}, 6665 } 6666 }, 6667 }, // End of an example 6668 }; 6669 return examples_dynamic_output_shape_nhwc_none_quant8; 6670 }; 6671 6672 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input() { 6673 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input = { 6674 // Begin of an example 6675 { 6676 .operands = { 6677 //Input(s) 6678 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6679 // int -> Dimensions map 6680 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6681 // int -> FLOAT32 map 6682 .float32Operands = {}, 6683 // int -> INT32 map 6684 .int32Operands = {{2, {-6, -8}}}, 6685 // int -> QUANT8_ASYMM map 6686 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 6687 // int -> QUANT16_SYMM map 6688 .quant16SymmOperands = {}, 6689 // int -> FLOAT16 map 6690 .float16Operands = {}, 6691 // int -> BOOL8 map 6692 .bool8Operands = {}, 6693 // int -> QUANT8_SYMM_PER_CHANNEL map 6694 .quant8ChannelOperands = {}, 6695 // int -> QUANT16_ASYMM map 6696 .quant16AsymmOperands = {}, 6697 // int -> QUANT8_SYMM map 6698 .quant8SymmOperands = {}, 6699 }, 6700 //Output(s) 6701 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6702 // int -> Dimensions map 6703 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6704 // int -> FLOAT32 map 6705 .float32Operands = {}, 6706 // int -> INT32 map 6707 .int32Operands = {}, 6708 // int -> QUANT8_ASYMM map 6709 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 6710 // int -> QUANT16_SYMM map 6711 .quant16SymmOperands = {}, 6712 // int -> FLOAT16 map 6713 .float16Operands = {}, 6714 // int -> BOOL8 map 6715 .bool8Operands = {}, 6716 // int -> QUANT8_SYMM_PER_CHANNEL map 6717 .quant8ChannelOperands = {}, 6718 // int -> QUANT16_ASYMM map 6719 .quant16AsymmOperands = {}, 6720 // int -> QUANT8_SYMM map 6721 .quant8SymmOperands = {}, 6722 } 6723 }, 6724 }, // End of an example 6725 }; 6726 return examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input; 6727 }; 6728 6729 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_2() { 6730 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_2 = { 6731 // Begin of an example 6732 { 6733 .operands = { 6734 //Input(s) 6735 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6736 // int -> Dimensions map 6737 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6738 // int -> FLOAT32 map 6739 .float32Operands = {}, 6740 // int -> INT32 map 6741 .int32Operands = {}, 6742 // int -> QUANT8_ASYMM map 6743 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 6744 // int -> QUANT16_SYMM map 6745 .quant16SymmOperands = {}, 6746 // int -> FLOAT16 map 6747 .float16Operands = {}, 6748 // int -> BOOL8 map 6749 .bool8Operands = {}, 6750 // int -> QUANT8_SYMM_PER_CHANNEL map 6751 .quant8ChannelOperands = {}, 6752 // int -> QUANT16_ASYMM map 6753 .quant16AsymmOperands = {}, 6754 // int -> QUANT8_SYMM map 6755 .quant8SymmOperands = {}, 6756 }, 6757 //Output(s) 6758 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6759 // int -> Dimensions map 6760 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6761 // int -> FLOAT32 map 6762 .float32Operands = {}, 6763 // int -> INT32 map 6764 .int32Operands = {}, 6765 // int -> QUANT8_ASYMM map 6766 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 6767 // int -> QUANT16_SYMM map 6768 .quant16SymmOperands = {}, 6769 // int -> FLOAT16 map 6770 .float16Operands = {}, 6771 // int -> BOOL8 map 6772 .bool8Operands = {}, 6773 // int -> QUANT8_SYMM_PER_CHANNEL map 6774 .quant8ChannelOperands = {}, 6775 // int -> QUANT16_ASYMM map 6776 .quant16AsymmOperands = {}, 6777 // int -> QUANT8_SYMM map 6778 .quant8SymmOperands = {}, 6779 } 6780 }, 6781 }, // End of an example 6782 }; 6783 return examples_dynamic_output_shape_nhwc_none_quant8_2; 6784 }; 6785 6786 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2() { 6787 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2 = { 6788 // Begin of an example 6789 { 6790 .operands = { 6791 //Input(s) 6792 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6793 // int -> Dimensions map 6794 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6795 // int -> FLOAT32 map 6796 .float32Operands = {}, 6797 // int -> INT32 map 6798 .int32Operands = {{2, {-6, -8}}}, 6799 // int -> QUANT8_ASYMM map 6800 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 6801 // int -> QUANT16_SYMM map 6802 .quant16SymmOperands = {}, 6803 // int -> FLOAT16 map 6804 .float16Operands = {}, 6805 // int -> BOOL8 map 6806 .bool8Operands = {}, 6807 // int -> QUANT8_SYMM_PER_CHANNEL map 6808 .quant8ChannelOperands = {}, 6809 // int -> QUANT16_ASYMM map 6810 .quant16AsymmOperands = {}, 6811 // int -> QUANT8_SYMM map 6812 .quant8SymmOperands = {}, 6813 }, 6814 //Output(s) 6815 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6816 // int -> Dimensions map 6817 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6818 // int -> FLOAT32 map 6819 .float32Operands = {}, 6820 // int -> INT32 map 6821 .int32Operands = {}, 6822 // int -> QUANT8_ASYMM map 6823 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 6824 // int -> QUANT16_SYMM map 6825 .quant16SymmOperands = {}, 6826 // int -> FLOAT16 map 6827 .float16Operands = {}, 6828 // int -> BOOL8 map 6829 .bool8Operands = {}, 6830 // int -> QUANT8_SYMM_PER_CHANNEL map 6831 .quant8ChannelOperands = {}, 6832 // int -> QUANT16_ASYMM map 6833 .quant16AsymmOperands = {}, 6834 // int -> QUANT8_SYMM map 6835 .quant8SymmOperands = {}, 6836 } 6837 }, 6838 }, // End of an example 6839 }; 6840 return examples_dynamic_output_shape_nhwc_none_quant8_weight_as_input_2; 6841 }; 6842 6843 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8() { 6844 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8 = { 6845 // Begin of an example 6846 { 6847 .operands = { 6848 //Input(s) 6849 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6850 // int -> Dimensions map 6851 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6852 // int -> FLOAT32 map 6853 .float32Operands = {}, 6854 // int -> INT32 map 6855 .int32Operands = {}, 6856 // int -> QUANT8_ASYMM map 6857 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6858 // int -> QUANT16_SYMM map 6859 .quant16SymmOperands = {}, 6860 // int -> FLOAT16 map 6861 .float16Operands = {}, 6862 // int -> BOOL8 map 6863 .bool8Operands = {}, 6864 // int -> QUANT8_SYMM_PER_CHANNEL map 6865 .quant8ChannelOperands = {}, 6866 // int -> QUANT16_ASYMM map 6867 .quant16AsymmOperands = {}, 6868 // int -> QUANT8_SYMM map 6869 .quant8SymmOperands = {}, 6870 }, 6871 //Output(s) 6872 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6873 // int -> Dimensions map 6874 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6875 // int -> FLOAT32 map 6876 .float32Operands = {}, 6877 // int -> INT32 map 6878 .int32Operands = {}, 6879 // int -> QUANT8_ASYMM map 6880 .quant8AsymmOperands = {{0, {79, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 6881 // int -> QUANT16_SYMM map 6882 .quant16SymmOperands = {}, 6883 // int -> FLOAT16 map 6884 .float16Operands = {}, 6885 // int -> BOOL8 map 6886 .bool8Operands = {}, 6887 // int -> QUANT8_SYMM_PER_CHANNEL map 6888 .quant8ChannelOperands = {}, 6889 // int -> QUANT16_ASYMM map 6890 .quant16AsymmOperands = {}, 6891 // int -> QUANT8_SYMM map 6892 .quant8SymmOperands = {}, 6893 } 6894 }, 6895 }, // End of an example 6896 }; 6897 return examples_dynamic_output_shape_nhwc_none_channelQuant8; 6898 }; 6899 6900 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input() { 6901 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input = { 6902 // Begin of an example 6903 { 6904 .operands = { 6905 //Input(s) 6906 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6907 // int -> Dimensions map 6908 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 6909 // int -> FLOAT32 map 6910 .float32Operands = {}, 6911 // int -> INT32 map 6912 .int32Operands = {{2, {-24, -16}}}, 6913 // int -> QUANT8_ASYMM map 6914 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6915 // int -> QUANT16_SYMM map 6916 .quant16SymmOperands = {}, 6917 // int -> FLOAT16 map 6918 .float16Operands = {}, 6919 // int -> BOOL8 map 6920 .bool8Operands = {}, 6921 // int -> QUANT8_SYMM_PER_CHANNEL map 6922 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 6923 // int -> QUANT16_ASYMM map 6924 .quant16AsymmOperands = {}, 6925 // int -> QUANT8_SYMM map 6926 .quant8SymmOperands = {}, 6927 }, 6928 //Output(s) 6929 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6930 // int -> Dimensions map 6931 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6932 // int -> FLOAT32 map 6933 .float32Operands = {}, 6934 // int -> INT32 map 6935 .int32Operands = {}, 6936 // int -> QUANT8_ASYMM map 6937 .quant8AsymmOperands = {{0, {79, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 6938 // int -> QUANT16_SYMM map 6939 .quant16SymmOperands = {}, 6940 // int -> FLOAT16 map 6941 .float16Operands = {}, 6942 // int -> BOOL8 map 6943 .bool8Operands = {}, 6944 // int -> QUANT8_SYMM_PER_CHANNEL map 6945 .quant8ChannelOperands = {}, 6946 // int -> QUANT16_ASYMM map 6947 .quant16AsymmOperands = {}, 6948 // int -> QUANT8_SYMM map 6949 .quant8SymmOperands = {}, 6950 } 6951 }, 6952 }, // End of an example 6953 }; 6954 return examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input; 6955 }; 6956 6957 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_2() { 6958 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_2 = { 6959 // Begin of an example 6960 { 6961 .operands = { 6962 //Input(s) 6963 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6964 // int -> Dimensions map 6965 .operandDimensions = {{0, {1, 2, 2, 1}}}, 6966 // int -> FLOAT32 map 6967 .float32Operands = {}, 6968 // int -> INT32 map 6969 .int32Operands = {}, 6970 // int -> QUANT8_ASYMM map 6971 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 6972 // int -> QUANT16_SYMM map 6973 .quant16SymmOperands = {}, 6974 // int -> FLOAT16 map 6975 .float16Operands = {}, 6976 // int -> BOOL8 map 6977 .bool8Operands = {}, 6978 // int -> QUANT8_SYMM_PER_CHANNEL map 6979 .quant8ChannelOperands = {}, 6980 // int -> QUANT16_ASYMM map 6981 .quant16AsymmOperands = {}, 6982 // int -> QUANT8_SYMM map 6983 .quant8SymmOperands = {}, 6984 }, 6985 //Output(s) 6986 { // See tools/test_generator/include/TestHarness.h:MixedTyped 6987 // int -> Dimensions map 6988 .operandDimensions = {{0, {1, 5, 5, 2}}}, 6989 // int -> FLOAT32 map 6990 .float32Operands = {}, 6991 // int -> INT32 map 6992 .int32Operands = {}, 6993 // int -> QUANT8_ASYMM map 6994 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 6995 // int -> QUANT16_SYMM map 6996 .quant16SymmOperands = {}, 6997 // int -> FLOAT16 map 6998 .float16Operands = {}, 6999 // int -> BOOL8 map 7000 .bool8Operands = {}, 7001 // int -> QUANT8_SYMM_PER_CHANNEL map 7002 .quant8ChannelOperands = {}, 7003 // int -> QUANT16_ASYMM map 7004 .quant16AsymmOperands = {}, 7005 // int -> QUANT8_SYMM map 7006 .quant8SymmOperands = {}, 7007 } 7008 }, 7009 }, // End of an example 7010 }; 7011 return examples_dynamic_output_shape_nhwc_none_channelQuant8_2; 7012 }; 7013 7014 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2() { 7015 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2 = { 7016 // Begin of an example 7017 { 7018 .operands = { 7019 //Input(s) 7020 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7021 // int -> Dimensions map 7022 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7023 // int -> FLOAT32 map 7024 .float32Operands = {}, 7025 // int -> INT32 map 7026 .int32Operands = {{2, {-24, -16}}}, 7027 // int -> QUANT8_ASYMM map 7028 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 7029 // int -> QUANT16_SYMM map 7030 .quant16SymmOperands = {}, 7031 // int -> FLOAT16 map 7032 .float16Operands = {}, 7033 // int -> BOOL8 map 7034 .bool8Operands = {}, 7035 // int -> QUANT8_SYMM_PER_CHANNEL map 7036 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 7037 // int -> QUANT16_ASYMM map 7038 .quant16AsymmOperands = {}, 7039 // int -> QUANT8_SYMM map 7040 .quant8SymmOperands = {}, 7041 }, 7042 //Output(s) 7043 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7044 // int -> Dimensions map 7045 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7046 // int -> FLOAT32 map 7047 .float32Operands = {}, 7048 // int -> INT32 map 7049 .int32Operands = {}, 7050 // int -> QUANT8_ASYMM map 7051 .quant8AsymmOperands = {{0, {75, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 7052 // int -> QUANT16_SYMM map 7053 .quant16SymmOperands = {}, 7054 // int -> FLOAT16 map 7055 .float16Operands = {}, 7056 // int -> BOOL8 map 7057 .bool8Operands = {}, 7058 // int -> QUANT8_SYMM_PER_CHANNEL map 7059 .quant8ChannelOperands = {}, 7060 // int -> QUANT16_ASYMM map 7061 .quant16AsymmOperands = {}, 7062 // int -> QUANT8_SYMM map 7063 .quant8SymmOperands = {}, 7064 } 7065 }, 7066 }, // End of an example 7067 }; 7068 return examples_dynamic_output_shape_nhwc_none_channelQuant8_weight_as_input_2; 7069 }; 7070 7071 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_float16() { 7072 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_float16 = { 7073 // Begin of an example 7074 { 7075 .operands = { 7076 //Input(s) 7077 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7078 // int -> Dimensions map 7079 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7080 // int -> FLOAT32 map 7081 .float32Operands = {}, 7082 // int -> INT32 map 7083 .int32Operands = {}, 7084 // int -> QUANT8_ASYMM map 7085 .quant8AsymmOperands = {}, 7086 // int -> QUANT16_SYMM map 7087 .quant16SymmOperands = {}, 7088 // int -> FLOAT16 map 7089 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 7090 // int -> BOOL8 map 7091 .bool8Operands = {}, 7092 // int -> QUANT8_SYMM_PER_CHANNEL map 7093 .quant8ChannelOperands = {}, 7094 // int -> QUANT16_ASYMM map 7095 .quant16AsymmOperands = {}, 7096 // int -> QUANT8_SYMM map 7097 .quant8SymmOperands = {}, 7098 }, 7099 //Output(s) 7100 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7101 // int -> Dimensions map 7102 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7103 // int -> FLOAT32 map 7104 .float32Operands = {}, 7105 // int -> INT32 map 7106 .int32Operands = {}, 7107 // int -> QUANT8_ASYMM map 7108 .quant8AsymmOperands = {}, 7109 // int -> QUANT16_SYMM map 7110 .quant16SymmOperands = {}, 7111 // int -> FLOAT16 map 7112 .float16Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7113 // int -> BOOL8 map 7114 .bool8Operands = {}, 7115 // int -> QUANT8_SYMM_PER_CHANNEL map 7116 .quant8ChannelOperands = {}, 7117 // int -> QUANT16_ASYMM map 7118 .quant16AsymmOperands = {}, 7119 // int -> QUANT8_SYMM map 7120 .quant8SymmOperands = {}, 7121 } 7122 }, 7123 }, // End of an example 7124 }; 7125 return examples_dynamic_output_shape_nhwc_none_float16; 7126 }; 7127 7128 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_none_float16_weight_as_input() { 7129 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_none_float16_weight_as_input = { 7130 // Begin of an example 7131 { 7132 .operands = { 7133 //Input(s) 7134 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7135 // int -> Dimensions map 7136 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7137 // int -> FLOAT32 map 7138 .float32Operands = {}, 7139 // int -> INT32 map 7140 .int32Operands = {}, 7141 // int -> QUANT8_ASYMM map 7142 .quant8AsymmOperands = {}, 7143 // int -> QUANT16_SYMM map 7144 .quant16SymmOperands = {}, 7145 // int -> FLOAT16 map 7146 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 7147 // int -> BOOL8 map 7148 .bool8Operands = {}, 7149 // int -> QUANT8_SYMM_PER_CHANNEL map 7150 .quant8ChannelOperands = {}, 7151 // int -> QUANT16_ASYMM map 7152 .quant16AsymmOperands = {}, 7153 // int -> QUANT8_SYMM map 7154 .quant8SymmOperands = {}, 7155 }, 7156 //Output(s) 7157 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7158 // int -> Dimensions map 7159 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7160 // int -> FLOAT32 map 7161 .float32Operands = {}, 7162 // int -> INT32 map 7163 .int32Operands = {}, 7164 // int -> QUANT8_ASYMM map 7165 .quant8AsymmOperands = {}, 7166 // int -> QUANT16_SYMM map 7167 .quant16SymmOperands = {}, 7168 // int -> FLOAT16 map 7169 .float16Operands = {{0, {-0.5f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7170 // int -> BOOL8 map 7171 .bool8Operands = {}, 7172 // int -> QUANT8_SYMM_PER_CHANNEL map 7173 .quant8ChannelOperands = {}, 7174 // int -> QUANT16_ASYMM map 7175 .quant16AsymmOperands = {}, 7176 // int -> QUANT8_SYMM map 7177 .quant8SymmOperands = {}, 7178 } 7179 }, 7180 }, // End of an example 7181 }; 7182 return examples_dynamic_output_shape_nhwc_none_float16_weight_as_input; 7183 }; 7184 7185 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu() { 7186 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu = { 7187 // Begin of an example 7188 { 7189 .operands = { 7190 //Input(s) 7191 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7192 // int -> Dimensions map 7193 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7194 // int -> FLOAT32 map 7195 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 7196 // int -> INT32 map 7197 .int32Operands = {}, 7198 // int -> QUANT8_ASYMM map 7199 .quant8AsymmOperands = {}, 7200 // int -> QUANT16_SYMM map 7201 .quant16SymmOperands = {}, 7202 // int -> FLOAT16 map 7203 .float16Operands = {}, 7204 // int -> BOOL8 map 7205 .bool8Operands = {}, 7206 // int -> QUANT8_SYMM_PER_CHANNEL map 7207 .quant8ChannelOperands = {}, 7208 // int -> QUANT16_ASYMM map 7209 .quant16AsymmOperands = {}, 7210 // int -> QUANT8_SYMM map 7211 .quant8SymmOperands = {}, 7212 }, 7213 //Output(s) 7214 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7215 // int -> Dimensions map 7216 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7217 // int -> FLOAT32 map 7218 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7219 // int -> INT32 map 7220 .int32Operands = {}, 7221 // int -> QUANT8_ASYMM map 7222 .quant8AsymmOperands = {}, 7223 // int -> QUANT16_SYMM map 7224 .quant16SymmOperands = {}, 7225 // int -> FLOAT16 map 7226 .float16Operands = {}, 7227 // int -> BOOL8 map 7228 .bool8Operands = {}, 7229 // int -> QUANT8_SYMM_PER_CHANNEL map 7230 .quant8ChannelOperands = {}, 7231 // int -> QUANT16_ASYMM map 7232 .quant16AsymmOperands = {}, 7233 // int -> QUANT8_SYMM map 7234 .quant8SymmOperands = {}, 7235 } 7236 }, 7237 }, // End of an example 7238 }; 7239 return examples_dynamic_output_shape_nhwc_relu; 7240 }; 7241 7242 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_weight_as_input() { 7243 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_weight_as_input = { 7244 // Begin of an example 7245 { 7246 .operands = { 7247 //Input(s) 7248 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7249 // int -> Dimensions map 7250 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7251 // int -> FLOAT32 map 7252 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 7253 // int -> INT32 map 7254 .int32Operands = {}, 7255 // int -> QUANT8_ASYMM map 7256 .quant8AsymmOperands = {}, 7257 // int -> QUANT16_SYMM map 7258 .quant16SymmOperands = {}, 7259 // int -> FLOAT16 map 7260 .float16Operands = {}, 7261 // int -> BOOL8 map 7262 .bool8Operands = {}, 7263 // int -> QUANT8_SYMM_PER_CHANNEL map 7264 .quant8ChannelOperands = {}, 7265 // int -> QUANT16_ASYMM map 7266 .quant16AsymmOperands = {}, 7267 // int -> QUANT8_SYMM map 7268 .quant8SymmOperands = {}, 7269 }, 7270 //Output(s) 7271 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7272 // int -> Dimensions map 7273 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7274 // int -> FLOAT32 map 7275 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7276 // int -> INT32 map 7277 .int32Operands = {}, 7278 // int -> QUANT8_ASYMM map 7279 .quant8AsymmOperands = {}, 7280 // int -> QUANT16_SYMM map 7281 .quant16SymmOperands = {}, 7282 // int -> FLOAT16 map 7283 .float16Operands = {}, 7284 // int -> BOOL8 map 7285 .bool8Operands = {}, 7286 // int -> QUANT8_SYMM_PER_CHANNEL map 7287 .quant8ChannelOperands = {}, 7288 // int -> QUANT16_ASYMM map 7289 .quant16AsymmOperands = {}, 7290 // int -> QUANT8_SYMM map 7291 .quant8SymmOperands = {}, 7292 } 7293 }, 7294 }, // End of an example 7295 }; 7296 return examples_dynamic_output_shape_nhwc_relu_weight_as_input; 7297 }; 7298 7299 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_relaxed() { 7300 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_relaxed = { 7301 // Begin of an example 7302 { 7303 .operands = { 7304 //Input(s) 7305 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7306 // int -> Dimensions map 7307 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7308 // int -> FLOAT32 map 7309 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 7310 // int -> INT32 map 7311 .int32Operands = {}, 7312 // int -> QUANT8_ASYMM map 7313 .quant8AsymmOperands = {}, 7314 // int -> QUANT16_SYMM map 7315 .quant16SymmOperands = {}, 7316 // int -> FLOAT16 map 7317 .float16Operands = {}, 7318 // int -> BOOL8 map 7319 .bool8Operands = {}, 7320 // int -> QUANT8_SYMM_PER_CHANNEL map 7321 .quant8ChannelOperands = {}, 7322 // int -> QUANT16_ASYMM map 7323 .quant16AsymmOperands = {}, 7324 // int -> QUANT8_SYMM map 7325 .quant8SymmOperands = {}, 7326 }, 7327 //Output(s) 7328 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7329 // int -> Dimensions map 7330 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7331 // int -> FLOAT32 map 7332 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7333 // int -> INT32 map 7334 .int32Operands = {}, 7335 // int -> QUANT8_ASYMM map 7336 .quant8AsymmOperands = {}, 7337 // int -> QUANT16_SYMM map 7338 .quant16SymmOperands = {}, 7339 // int -> FLOAT16 map 7340 .float16Operands = {}, 7341 // int -> BOOL8 map 7342 .bool8Operands = {}, 7343 // int -> QUANT8_SYMM_PER_CHANNEL map 7344 .quant8ChannelOperands = {}, 7345 // int -> QUANT16_ASYMM map 7346 .quant16AsymmOperands = {}, 7347 // int -> QUANT8_SYMM map 7348 .quant8SymmOperands = {}, 7349 } 7350 }, 7351 }, // End of an example 7352 }; 7353 return examples_dynamic_output_shape_nhwc_relu_relaxed; 7354 }; 7355 7356 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input() { 7357 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input = { 7358 // Begin of an example 7359 { 7360 .operands = { 7361 //Input(s) 7362 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7363 // int -> Dimensions map 7364 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7365 // int -> FLOAT32 map 7366 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 7367 // int -> INT32 map 7368 .int32Operands = {}, 7369 // int -> QUANT8_ASYMM map 7370 .quant8AsymmOperands = {}, 7371 // int -> QUANT16_SYMM map 7372 .quant16SymmOperands = {}, 7373 // int -> FLOAT16 map 7374 .float16Operands = {}, 7375 // int -> BOOL8 map 7376 .bool8Operands = {}, 7377 // int -> QUANT8_SYMM_PER_CHANNEL map 7378 .quant8ChannelOperands = {}, 7379 // int -> QUANT16_ASYMM map 7380 .quant16AsymmOperands = {}, 7381 // int -> QUANT8_SYMM map 7382 .quant8SymmOperands = {}, 7383 }, 7384 //Output(s) 7385 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7386 // int -> Dimensions map 7387 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7388 // int -> FLOAT32 map 7389 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7390 // int -> INT32 map 7391 .int32Operands = {}, 7392 // int -> QUANT8_ASYMM map 7393 .quant8AsymmOperands = {}, 7394 // int -> QUANT16_SYMM map 7395 .quant16SymmOperands = {}, 7396 // int -> FLOAT16 map 7397 .float16Operands = {}, 7398 // int -> BOOL8 map 7399 .bool8Operands = {}, 7400 // int -> QUANT8_SYMM_PER_CHANNEL map 7401 .quant8ChannelOperands = {}, 7402 // int -> QUANT16_ASYMM map 7403 .quant16AsymmOperands = {}, 7404 // int -> QUANT8_SYMM map 7405 .quant8SymmOperands = {}, 7406 } 7407 }, 7408 }, // End of an example 7409 }; 7410 return examples_dynamic_output_shape_nhwc_relu_relaxed_weight_as_input; 7411 }; 7412 7413 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8() { 7414 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8 = { 7415 // Begin of an example 7416 { 7417 .operands = { 7418 //Input(s) 7419 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7420 // int -> Dimensions map 7421 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7422 // int -> FLOAT32 map 7423 .float32Operands = {}, 7424 // int -> INT32 map 7425 .int32Operands = {}, 7426 // int -> QUANT8_ASYMM map 7427 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 7428 // int -> QUANT16_SYMM map 7429 .quant16SymmOperands = {}, 7430 // int -> FLOAT16 map 7431 .float16Operands = {}, 7432 // int -> BOOL8 map 7433 .bool8Operands = {}, 7434 // int -> QUANT8_SYMM_PER_CHANNEL map 7435 .quant8ChannelOperands = {}, 7436 // int -> QUANT16_ASYMM map 7437 .quant16AsymmOperands = {}, 7438 // int -> QUANT8_SYMM map 7439 .quant8SymmOperands = {}, 7440 }, 7441 //Output(s) 7442 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7443 // int -> Dimensions map 7444 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7445 // int -> FLOAT32 map 7446 .float32Operands = {}, 7447 // int -> INT32 map 7448 .int32Operands = {}, 7449 // int -> QUANT8_ASYMM map 7450 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 7451 // int -> QUANT16_SYMM map 7452 .quant16SymmOperands = {}, 7453 // int -> FLOAT16 map 7454 .float16Operands = {}, 7455 // int -> BOOL8 map 7456 .bool8Operands = {}, 7457 // int -> QUANT8_SYMM_PER_CHANNEL map 7458 .quant8ChannelOperands = {}, 7459 // int -> QUANT16_ASYMM map 7460 .quant16AsymmOperands = {}, 7461 // int -> QUANT8_SYMM map 7462 .quant8SymmOperands = {}, 7463 } 7464 }, 7465 }, // End of an example 7466 }; 7467 return examples_dynamic_output_shape_nhwc_relu_quant8; 7468 }; 7469 7470 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input() { 7471 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input = { 7472 // Begin of an example 7473 { 7474 .operands = { 7475 //Input(s) 7476 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7477 // int -> Dimensions map 7478 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7479 // int -> FLOAT32 map 7480 .float32Operands = {}, 7481 // int -> INT32 map 7482 .int32Operands = {{2, {-6, -8}}}, 7483 // int -> QUANT8_ASYMM map 7484 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 7485 // int -> QUANT16_SYMM map 7486 .quant16SymmOperands = {}, 7487 // int -> FLOAT16 map 7488 .float16Operands = {}, 7489 // int -> BOOL8 map 7490 .bool8Operands = {}, 7491 // int -> QUANT8_SYMM_PER_CHANNEL map 7492 .quant8ChannelOperands = {}, 7493 // int -> QUANT16_ASYMM map 7494 .quant16AsymmOperands = {}, 7495 // int -> QUANT8_SYMM map 7496 .quant8SymmOperands = {}, 7497 }, 7498 //Output(s) 7499 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7500 // int -> Dimensions map 7501 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7502 // int -> FLOAT32 map 7503 .float32Operands = {}, 7504 // int -> INT32 map 7505 .int32Operands = {}, 7506 // int -> QUANT8_ASYMM map 7507 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 16, 9, 12, 17, 20, 11, 12, 15, 16, 47, 52, 33, 36, 41, 44, 29, 36, 45, 52, 121, 140, 81, 92, 105, 116, 39, 44, 51, 56, 119, 132, 69, 76, 85, 92, 75, 80, 87, 92, 203, 216, 117, 124, 133, 140}}}, 7508 // int -> QUANT16_SYMM map 7509 .quant16SymmOperands = {}, 7510 // int -> FLOAT16 map 7511 .float16Operands = {}, 7512 // int -> BOOL8 map 7513 .bool8Operands = {}, 7514 // int -> QUANT8_SYMM_PER_CHANNEL map 7515 .quant8ChannelOperands = {}, 7516 // int -> QUANT16_ASYMM map 7517 .quant16AsymmOperands = {}, 7518 // int -> QUANT8_SYMM map 7519 .quant8SymmOperands = {}, 7520 } 7521 }, 7522 }, // End of an example 7523 }; 7524 return examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input; 7525 }; 7526 7527 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_2() { 7528 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_2 = { 7529 // Begin of an example 7530 { 7531 .operands = { 7532 //Input(s) 7533 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7534 // int -> Dimensions map 7535 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7536 // int -> FLOAT32 map 7537 .float32Operands = {}, 7538 // int -> INT32 map 7539 .int32Operands = {}, 7540 // int -> QUANT8_ASYMM map 7541 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 7542 // int -> QUANT16_SYMM map 7543 .quant16SymmOperands = {}, 7544 // int -> FLOAT16 map 7545 .float16Operands = {}, 7546 // int -> BOOL8 map 7547 .bool8Operands = {}, 7548 // int -> QUANT8_SYMM_PER_CHANNEL map 7549 .quant8ChannelOperands = {}, 7550 // int -> QUANT16_ASYMM map 7551 .quant16AsymmOperands = {}, 7552 // int -> QUANT8_SYMM map 7553 .quant8SymmOperands = {}, 7554 }, 7555 //Output(s) 7556 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7557 // int -> Dimensions map 7558 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7559 // int -> FLOAT32 map 7560 .float32Operands = {}, 7561 // int -> INT32 map 7562 .int32Operands = {}, 7563 // int -> QUANT8_ASYMM map 7564 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 7565 // int -> QUANT16_SYMM map 7566 .quant16SymmOperands = {}, 7567 // int -> FLOAT16 map 7568 .float16Operands = {}, 7569 // int -> BOOL8 map 7570 .bool8Operands = {}, 7571 // int -> QUANT8_SYMM_PER_CHANNEL map 7572 .quant8ChannelOperands = {}, 7573 // int -> QUANT16_ASYMM map 7574 .quant16AsymmOperands = {}, 7575 // int -> QUANT8_SYMM map 7576 .quant8SymmOperands = {}, 7577 } 7578 }, 7579 }, // End of an example 7580 }; 7581 return examples_dynamic_output_shape_nhwc_relu_quant8_2; 7582 }; 7583 7584 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2() { 7585 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2 = { 7586 // Begin of an example 7587 { 7588 .operands = { 7589 //Input(s) 7590 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7591 // int -> Dimensions map 7592 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7593 // int -> FLOAT32 map 7594 .float32Operands = {}, 7595 // int -> INT32 map 7596 .int32Operands = {{2, {-6, -8}}}, 7597 // int -> QUANT8_ASYMM map 7598 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 7599 // int -> QUANT16_SYMM map 7600 .quant16SymmOperands = {}, 7601 // int -> FLOAT16 map 7602 .float16Operands = {}, 7603 // int -> BOOL8 map 7604 .bool8Operands = {}, 7605 // int -> QUANT8_SYMM_PER_CHANNEL map 7606 .quant8ChannelOperands = {}, 7607 // int -> QUANT16_ASYMM map 7608 .quant16AsymmOperands = {}, 7609 // int -> QUANT8_SYMM map 7610 .quant8SymmOperands = {}, 7611 }, 7612 //Output(s) 7613 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7614 // int -> Dimensions map 7615 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7616 // int -> FLOAT32 map 7617 .float32Operands = {}, 7618 // int -> INT32 map 7619 .int32Operands = {}, 7620 // int -> QUANT8_ASYMM map 7621 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 7622 // int -> QUANT16_SYMM map 7623 .quant16SymmOperands = {}, 7624 // int -> FLOAT16 map 7625 .float16Operands = {}, 7626 // int -> BOOL8 map 7627 .bool8Operands = {}, 7628 // int -> QUANT8_SYMM_PER_CHANNEL map 7629 .quant8ChannelOperands = {}, 7630 // int -> QUANT16_ASYMM map 7631 .quant16AsymmOperands = {}, 7632 // int -> QUANT8_SYMM map 7633 .quant8SymmOperands = {}, 7634 } 7635 }, 7636 }, // End of an example 7637 }; 7638 return examples_dynamic_output_shape_nhwc_relu_quant8_weight_as_input_2; 7639 }; 7640 7641 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8() { 7642 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8 = { 7643 // Begin of an example 7644 { 7645 .operands = { 7646 //Input(s) 7647 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7648 // int -> Dimensions map 7649 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7650 // int -> FLOAT32 map 7651 .float32Operands = {}, 7652 // int -> INT32 map 7653 .int32Operands = {}, 7654 // int -> QUANT8_ASYMM map 7655 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 7656 // int -> QUANT16_SYMM map 7657 .quant16SymmOperands = {}, 7658 // int -> FLOAT16 map 7659 .float16Operands = {}, 7660 // int -> BOOL8 map 7661 .bool8Operands = {}, 7662 // int -> QUANT8_SYMM_PER_CHANNEL map 7663 .quant8ChannelOperands = {}, 7664 // int -> QUANT16_ASYMM map 7665 .quant16AsymmOperands = {}, 7666 // int -> QUANT8_SYMM map 7667 .quant8SymmOperands = {}, 7668 }, 7669 //Output(s) 7670 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7671 // int -> Dimensions map 7672 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7673 // int -> FLOAT32 map 7674 .float32Operands = {}, 7675 // int -> INT32 map 7676 .int32Operands = {}, 7677 // int -> QUANT8_ASYMM map 7678 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 7679 // int -> QUANT16_SYMM map 7680 .quant16SymmOperands = {}, 7681 // int -> FLOAT16 map 7682 .float16Operands = {}, 7683 // int -> BOOL8 map 7684 .bool8Operands = {}, 7685 // int -> QUANT8_SYMM_PER_CHANNEL map 7686 .quant8ChannelOperands = {}, 7687 // int -> QUANT16_ASYMM map 7688 .quant16AsymmOperands = {}, 7689 // int -> QUANT8_SYMM map 7690 .quant8SymmOperands = {}, 7691 } 7692 }, 7693 }, // End of an example 7694 }; 7695 return examples_dynamic_output_shape_nhwc_relu_channelQuant8; 7696 }; 7697 7698 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input() { 7699 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input = { 7700 // Begin of an example 7701 { 7702 .operands = { 7703 //Input(s) 7704 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7705 // int -> Dimensions map 7706 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7707 // int -> FLOAT32 map 7708 .float32Operands = {}, 7709 // int -> INT32 map 7710 .int32Operands = {{2, {-24, -16}}}, 7711 // int -> QUANT8_ASYMM map 7712 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 7713 // int -> QUANT16_SYMM map 7714 .quant16SymmOperands = {}, 7715 // int -> FLOAT16 map 7716 .float16Operands = {}, 7717 // int -> BOOL8 map 7718 .bool8Operands = {}, 7719 // int -> QUANT8_SYMM_PER_CHANNEL map 7720 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 7721 // int -> QUANT16_ASYMM map 7722 .quant16AsymmOperands = {}, 7723 // int -> QUANT8_SYMM map 7724 .quant8SymmOperands = {}, 7725 }, 7726 //Output(s) 7727 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7728 // int -> Dimensions map 7729 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7730 // int -> FLOAT32 map 7731 .float32Operands = {}, 7732 // int -> INT32 map 7733 .int32Operands = {}, 7734 // int -> QUANT8_ASYMM map 7735 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 96, 89, 92, 97, 100, 91, 92, 95, 96, 127, 132, 113, 116, 121, 124, 109, 116, 125, 132, 201, 220, 161, 172, 185, 196, 119, 124, 131, 136, 199, 212, 149, 156, 165, 172, 155, 160, 167, 172, 255, 255, 197, 204, 213, 220}}}, 7736 // int -> QUANT16_SYMM map 7737 .quant16SymmOperands = {}, 7738 // int -> FLOAT16 map 7739 .float16Operands = {}, 7740 // int -> BOOL8 map 7741 .bool8Operands = {}, 7742 // int -> QUANT8_SYMM_PER_CHANNEL map 7743 .quant8ChannelOperands = {}, 7744 // int -> QUANT16_ASYMM map 7745 .quant16AsymmOperands = {}, 7746 // int -> QUANT8_SYMM map 7747 .quant8SymmOperands = {}, 7748 } 7749 }, 7750 }, // End of an example 7751 }; 7752 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input; 7753 }; 7754 7755 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_2() { 7756 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_2 = { 7757 // Begin of an example 7758 { 7759 .operands = { 7760 //Input(s) 7761 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7762 // int -> Dimensions map 7763 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7764 // int -> FLOAT32 map 7765 .float32Operands = {}, 7766 // int -> INT32 map 7767 .int32Operands = {}, 7768 // int -> QUANT8_ASYMM map 7769 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 7770 // int -> QUANT16_SYMM map 7771 .quant16SymmOperands = {}, 7772 // int -> FLOAT16 map 7773 .float16Operands = {}, 7774 // int -> BOOL8 map 7775 .bool8Operands = {}, 7776 // int -> QUANT8_SYMM_PER_CHANNEL map 7777 .quant8ChannelOperands = {}, 7778 // int -> QUANT16_ASYMM map 7779 .quant16AsymmOperands = {}, 7780 // int -> QUANT8_SYMM map 7781 .quant8SymmOperands = {}, 7782 }, 7783 //Output(s) 7784 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7785 // int -> Dimensions map 7786 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7787 // int -> FLOAT32 map 7788 .float32Operands = {}, 7789 // int -> INT32 map 7790 .int32Operands = {}, 7791 // int -> QUANT8_ASYMM map 7792 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 7793 // int -> QUANT16_SYMM map 7794 .quant16SymmOperands = {}, 7795 // int -> FLOAT16 map 7796 .float16Operands = {}, 7797 // int -> BOOL8 map 7798 .bool8Operands = {}, 7799 // int -> QUANT8_SYMM_PER_CHANNEL map 7800 .quant8ChannelOperands = {}, 7801 // int -> QUANT16_ASYMM map 7802 .quant16AsymmOperands = {}, 7803 // int -> QUANT8_SYMM map 7804 .quant8SymmOperands = {}, 7805 } 7806 }, 7807 }, // End of an example 7808 }; 7809 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_2; 7810 }; 7811 7812 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2() { 7813 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2 = { 7814 // Begin of an example 7815 { 7816 .operands = { 7817 //Input(s) 7818 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7819 // int -> Dimensions map 7820 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7821 // int -> FLOAT32 map 7822 .float32Operands = {}, 7823 // int -> INT32 map 7824 .int32Operands = {{2, {-24, -16}}}, 7825 // int -> QUANT8_ASYMM map 7826 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 7827 // int -> QUANT16_SYMM map 7828 .quant16SymmOperands = {}, 7829 // int -> FLOAT16 map 7830 .float16Operands = {}, 7831 // int -> BOOL8 map 7832 .bool8Operands = {}, 7833 // int -> QUANT8_SYMM_PER_CHANNEL map 7834 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 7835 // int -> QUANT16_ASYMM map 7836 .quant16AsymmOperands = {}, 7837 // int -> QUANT8_SYMM map 7838 .quant8SymmOperands = {}, 7839 }, 7840 //Output(s) 7841 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7842 // int -> Dimensions map 7843 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7844 // int -> FLOAT32 map 7845 .float32Operands = {}, 7846 // int -> INT32 map 7847 .int32Operands = {}, 7848 // int -> QUANT8_ASYMM map 7849 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 160, 125, 140, 165, 180, 135, 140, 155, 160, 255, 255, 245, 255, 255, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 7850 // int -> QUANT16_SYMM map 7851 .quant16SymmOperands = {}, 7852 // int -> FLOAT16 map 7853 .float16Operands = {}, 7854 // int -> BOOL8 map 7855 .bool8Operands = {}, 7856 // int -> QUANT8_SYMM_PER_CHANNEL map 7857 .quant8ChannelOperands = {}, 7858 // int -> QUANT16_ASYMM map 7859 .quant16AsymmOperands = {}, 7860 // int -> QUANT8_SYMM map 7861 .quant8SymmOperands = {}, 7862 } 7863 }, 7864 }, // End of an example 7865 }; 7866 return examples_dynamic_output_shape_nhwc_relu_channelQuant8_weight_as_input_2; 7867 }; 7868 7869 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_float16() { 7870 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_float16 = { 7871 // Begin of an example 7872 { 7873 .operands = { 7874 //Input(s) 7875 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7876 // int -> Dimensions map 7877 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7878 // int -> FLOAT32 map 7879 .float32Operands = {}, 7880 // int -> INT32 map 7881 .int32Operands = {}, 7882 // int -> QUANT8_ASYMM map 7883 .quant8AsymmOperands = {}, 7884 // int -> QUANT16_SYMM map 7885 .quant16SymmOperands = {}, 7886 // int -> FLOAT16 map 7887 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 7888 // int -> BOOL8 map 7889 .bool8Operands = {}, 7890 // int -> QUANT8_SYMM_PER_CHANNEL map 7891 .quant8ChannelOperands = {}, 7892 // int -> QUANT16_ASYMM map 7893 .quant16AsymmOperands = {}, 7894 // int -> QUANT8_SYMM map 7895 .quant8SymmOperands = {}, 7896 }, 7897 //Output(s) 7898 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7899 // int -> Dimensions map 7900 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7901 // int -> FLOAT32 map 7902 .float32Operands = {}, 7903 // int -> INT32 map 7904 .int32Operands = {}, 7905 // int -> QUANT8_ASYMM map 7906 .quant8AsymmOperands = {}, 7907 // int -> QUANT16_SYMM map 7908 .quant16SymmOperands = {}, 7909 // int -> FLOAT16 map 7910 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7911 // int -> BOOL8 map 7912 .bool8Operands = {}, 7913 // int -> QUANT8_SYMM_PER_CHANNEL map 7914 .quant8ChannelOperands = {}, 7915 // int -> QUANT16_ASYMM map 7916 .quant16AsymmOperands = {}, 7917 // int -> QUANT8_SYMM map 7918 .quant8SymmOperands = {}, 7919 } 7920 }, 7921 }, // End of an example 7922 }; 7923 return examples_dynamic_output_shape_nhwc_relu_float16; 7924 }; 7925 7926 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input() { 7927 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input = { 7928 // Begin of an example 7929 { 7930 .operands = { 7931 //Input(s) 7932 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7933 // int -> Dimensions map 7934 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 7935 // int -> FLOAT32 map 7936 .float32Operands = {}, 7937 // int -> INT32 map 7938 .int32Operands = {}, 7939 // int -> QUANT8_ASYMM map 7940 .quant8AsymmOperands = {}, 7941 // int -> QUANT16_SYMM map 7942 .quant16SymmOperands = {}, 7943 // int -> FLOAT16 map 7944 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 7945 // int -> BOOL8 map 7946 .bool8Operands = {}, 7947 // int -> QUANT8_SYMM_PER_CHANNEL map 7948 .quant8ChannelOperands = {}, 7949 // int -> QUANT16_ASYMM map 7950 .quant16AsymmOperands = {}, 7951 // int -> QUANT8_SYMM map 7952 .quant8SymmOperands = {}, 7953 }, 7954 //Output(s) 7955 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7956 // int -> Dimensions map 7957 .operandDimensions = {{0, {1, 5, 5, 2}}}, 7958 // int -> FLOAT32 map 7959 .float32Operands = {}, 7960 // int -> INT32 map 7961 .int32Operands = {}, 7962 // int -> QUANT8_ASYMM map 7963 .quant8AsymmOperands = {}, 7964 // int -> QUANT16_SYMM map 7965 .quant16SymmOperands = {}, 7966 // int -> FLOAT16 map 7967 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 8.0f, 4.5f, 6.0f, 8.5f, 10.0f, 5.5f, 6.0f, 7.5f, 8.0f, 23.5f, 26.0f, 16.5f, 18.0f, 20.5f, 22.0f, 14.5f, 18.0f, 22.5f, 26.0f, 60.5f, 70.0f, 40.5f, 46.0f, 52.5f, 58.0f, 19.5f, 22.0f, 25.5f, 28.0f, 59.5f, 66.0f, 34.5f, 38.0f, 42.5f, 46.0f, 37.5f, 40.0f, 43.5f, 46.0f, 101.5f, 108.0f, 58.5f, 62.0f, 66.5f, 70.0f}}}, 7968 // int -> BOOL8 map 7969 .bool8Operands = {}, 7970 // int -> QUANT8_SYMM_PER_CHANNEL map 7971 .quant8ChannelOperands = {}, 7972 // int -> QUANT16_ASYMM map 7973 .quant16AsymmOperands = {}, 7974 // int -> QUANT8_SYMM map 7975 .quant8SymmOperands = {}, 7976 } 7977 }, 7978 }, // End of an example 7979 }; 7980 return examples_dynamic_output_shape_nhwc_relu_float16_weight_as_input; 7981 }; 7982 7983 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1() { 7984 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1 = { 7985 // Begin of an example 7986 { 7987 .operands = { 7988 //Input(s) 7989 { // See tools/test_generator/include/TestHarness.h:MixedTyped 7990 // int -> Dimensions map 7991 .operandDimensions = {{0, {1, 2, 2, 1}}}, 7992 // int -> FLOAT32 map 7993 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 7994 // int -> INT32 map 7995 .int32Operands = {}, 7996 // int -> QUANT8_ASYMM map 7997 .quant8AsymmOperands = {}, 7998 // int -> QUANT16_SYMM map 7999 .quant16SymmOperands = {}, 8000 // int -> FLOAT16 map 8001 .float16Operands = {}, 8002 // int -> BOOL8 map 8003 .bool8Operands = {}, 8004 // int -> QUANT8_SYMM_PER_CHANNEL map 8005 .quant8ChannelOperands = {}, 8006 // int -> QUANT16_ASYMM map 8007 .quant16AsymmOperands = {}, 8008 // int -> QUANT8_SYMM map 8009 .quant8SymmOperands = {}, 8010 }, 8011 //Output(s) 8012 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8013 // int -> Dimensions map 8014 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8015 // int -> FLOAT32 map 8016 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8017 // int -> INT32 map 8018 .int32Operands = {}, 8019 // int -> QUANT8_ASYMM map 8020 .quant8AsymmOperands = {}, 8021 // int -> QUANT16_SYMM map 8022 .quant16SymmOperands = {}, 8023 // int -> FLOAT16 map 8024 .float16Operands = {}, 8025 // int -> BOOL8 map 8026 .bool8Operands = {}, 8027 // int -> QUANT8_SYMM_PER_CHANNEL map 8028 .quant8ChannelOperands = {}, 8029 // int -> QUANT16_ASYMM map 8030 .quant16AsymmOperands = {}, 8031 // int -> QUANT8_SYMM map 8032 .quant8SymmOperands = {}, 8033 } 8034 }, 8035 }, // End of an example 8036 }; 8037 return examples_dynamic_output_shape_nhwc_relu1; 8038 }; 8039 8040 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_weight_as_input() { 8041 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_weight_as_input = { 8042 // Begin of an example 8043 { 8044 .operands = { 8045 //Input(s) 8046 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8047 // int -> Dimensions map 8048 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8049 // int -> FLOAT32 map 8050 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 8051 // int -> INT32 map 8052 .int32Operands = {}, 8053 // int -> QUANT8_ASYMM map 8054 .quant8AsymmOperands = {}, 8055 // int -> QUANT16_SYMM map 8056 .quant16SymmOperands = {}, 8057 // int -> FLOAT16 map 8058 .float16Operands = {}, 8059 // int -> BOOL8 map 8060 .bool8Operands = {}, 8061 // int -> QUANT8_SYMM_PER_CHANNEL map 8062 .quant8ChannelOperands = {}, 8063 // int -> QUANT16_ASYMM map 8064 .quant16AsymmOperands = {}, 8065 // int -> QUANT8_SYMM map 8066 .quant8SymmOperands = {}, 8067 }, 8068 //Output(s) 8069 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8070 // int -> Dimensions map 8071 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8072 // int -> FLOAT32 map 8073 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8074 // int -> INT32 map 8075 .int32Operands = {}, 8076 // int -> QUANT8_ASYMM map 8077 .quant8AsymmOperands = {}, 8078 // int -> QUANT16_SYMM map 8079 .quant16SymmOperands = {}, 8080 // int -> FLOAT16 map 8081 .float16Operands = {}, 8082 // int -> BOOL8 map 8083 .bool8Operands = {}, 8084 // int -> QUANT8_SYMM_PER_CHANNEL map 8085 .quant8ChannelOperands = {}, 8086 // int -> QUANT16_ASYMM map 8087 .quant16AsymmOperands = {}, 8088 // int -> QUANT8_SYMM map 8089 .quant8SymmOperands = {}, 8090 } 8091 }, 8092 }, // End of an example 8093 }; 8094 return examples_dynamic_output_shape_nhwc_relu1_weight_as_input; 8095 }; 8096 8097 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_relaxed() { 8098 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_relaxed = { 8099 // Begin of an example 8100 { 8101 .operands = { 8102 //Input(s) 8103 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8104 // int -> Dimensions map 8105 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8106 // int -> FLOAT32 map 8107 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 8108 // int -> INT32 map 8109 .int32Operands = {}, 8110 // int -> QUANT8_ASYMM map 8111 .quant8AsymmOperands = {}, 8112 // int -> QUANT16_SYMM map 8113 .quant16SymmOperands = {}, 8114 // int -> FLOAT16 map 8115 .float16Operands = {}, 8116 // int -> BOOL8 map 8117 .bool8Operands = {}, 8118 // int -> QUANT8_SYMM_PER_CHANNEL map 8119 .quant8ChannelOperands = {}, 8120 // int -> QUANT16_ASYMM map 8121 .quant16AsymmOperands = {}, 8122 // int -> QUANT8_SYMM map 8123 .quant8SymmOperands = {}, 8124 }, 8125 //Output(s) 8126 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8127 // int -> Dimensions map 8128 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8129 // int -> FLOAT32 map 8130 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8131 // int -> INT32 map 8132 .int32Operands = {}, 8133 // int -> QUANT8_ASYMM map 8134 .quant8AsymmOperands = {}, 8135 // int -> QUANT16_SYMM map 8136 .quant16SymmOperands = {}, 8137 // int -> FLOAT16 map 8138 .float16Operands = {}, 8139 // int -> BOOL8 map 8140 .bool8Operands = {}, 8141 // int -> QUANT8_SYMM_PER_CHANNEL map 8142 .quant8ChannelOperands = {}, 8143 // int -> QUANT16_ASYMM map 8144 .quant16AsymmOperands = {}, 8145 // int -> QUANT8_SYMM map 8146 .quant8SymmOperands = {}, 8147 } 8148 }, 8149 }, // End of an example 8150 }; 8151 return examples_dynamic_output_shape_nhwc_relu1_relaxed; 8152 }; 8153 8154 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input() { 8155 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input = { 8156 // Begin of an example 8157 { 8158 .operands = { 8159 //Input(s) 8160 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8161 // int -> Dimensions map 8162 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8163 // int -> FLOAT32 map 8164 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 8165 // int -> INT32 map 8166 .int32Operands = {}, 8167 // int -> QUANT8_ASYMM map 8168 .quant8AsymmOperands = {}, 8169 // int -> QUANT16_SYMM map 8170 .quant16SymmOperands = {}, 8171 // int -> FLOAT16 map 8172 .float16Operands = {}, 8173 // int -> BOOL8 map 8174 .bool8Operands = {}, 8175 // int -> QUANT8_SYMM_PER_CHANNEL map 8176 .quant8ChannelOperands = {}, 8177 // int -> QUANT16_ASYMM map 8178 .quant16AsymmOperands = {}, 8179 // int -> QUANT8_SYMM map 8180 .quant8SymmOperands = {}, 8181 }, 8182 //Output(s) 8183 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8184 // int -> Dimensions map 8185 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8186 // int -> FLOAT32 map 8187 .float32Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8188 // int -> INT32 map 8189 .int32Operands = {}, 8190 // int -> QUANT8_ASYMM map 8191 .quant8AsymmOperands = {}, 8192 // int -> QUANT16_SYMM map 8193 .quant16SymmOperands = {}, 8194 // int -> FLOAT16 map 8195 .float16Operands = {}, 8196 // int -> BOOL8 map 8197 .bool8Operands = {}, 8198 // int -> QUANT8_SYMM_PER_CHANNEL map 8199 .quant8ChannelOperands = {}, 8200 // int -> QUANT16_ASYMM map 8201 .quant16AsymmOperands = {}, 8202 // int -> QUANT8_SYMM map 8203 .quant8SymmOperands = {}, 8204 } 8205 }, 8206 }, // End of an example 8207 }; 8208 return examples_dynamic_output_shape_nhwc_relu1_relaxed_weight_as_input; 8209 }; 8210 8211 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8() { 8212 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8 = { 8213 // Begin of an example 8214 { 8215 .operands = { 8216 //Input(s) 8217 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8218 // int -> Dimensions map 8219 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8220 // int -> FLOAT32 map 8221 .float32Operands = {}, 8222 // int -> INT32 map 8223 .int32Operands = {}, 8224 // int -> QUANT8_ASYMM map 8225 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 8226 // int -> QUANT16_SYMM map 8227 .quant16SymmOperands = {}, 8228 // int -> FLOAT16 map 8229 .float16Operands = {}, 8230 // int -> BOOL8 map 8231 .bool8Operands = {}, 8232 // int -> QUANT8_SYMM_PER_CHANNEL map 8233 .quant8ChannelOperands = {}, 8234 // int -> QUANT16_ASYMM map 8235 .quant16AsymmOperands = {}, 8236 // int -> QUANT8_SYMM map 8237 .quant8SymmOperands = {}, 8238 }, 8239 //Output(s) 8240 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8241 // int -> Dimensions map 8242 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8243 // int -> FLOAT32 map 8244 .float32Operands = {}, 8245 // int -> INT32 map 8246 .int32Operands = {}, 8247 // int -> QUANT8_ASYMM map 8248 .quant8AsymmOperands = {{0, {0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 8249 // int -> QUANT16_SYMM map 8250 .quant16SymmOperands = {}, 8251 // int -> FLOAT16 map 8252 .float16Operands = {}, 8253 // int -> BOOL8 map 8254 .bool8Operands = {}, 8255 // int -> QUANT8_SYMM_PER_CHANNEL map 8256 .quant8ChannelOperands = {}, 8257 // int -> QUANT16_ASYMM map 8258 .quant16AsymmOperands = {}, 8259 // int -> QUANT8_SYMM map 8260 .quant8SymmOperands = {}, 8261 } 8262 }, 8263 }, // End of an example 8264 }; 8265 return examples_dynamic_output_shape_nhwc_relu1_quant8; 8266 }; 8267 8268 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input() { 8269 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input = { 8270 // Begin of an example 8271 { 8272 .operands = { 8273 //Input(s) 8274 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8275 // int -> Dimensions map 8276 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8277 // int -> FLOAT32 map 8278 .float32Operands = {}, 8279 // int -> INT32 map 8280 .int32Operands = {{2, {-6, -8}}}, 8281 // int -> QUANT8_ASYMM map 8282 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 8283 // int -> QUANT16_SYMM map 8284 .quant16SymmOperands = {}, 8285 // int -> FLOAT16 map 8286 .float16Operands = {}, 8287 // int -> BOOL8 map 8288 .bool8Operands = {}, 8289 // int -> QUANT8_SYMM_PER_CHANNEL map 8290 .quant8ChannelOperands = {}, 8291 // int -> QUANT16_ASYMM map 8292 .quant16AsymmOperands = {}, 8293 // int -> QUANT8_SYMM map 8294 .quant8SymmOperands = {}, 8295 }, 8296 //Output(s) 8297 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8298 // int -> Dimensions map 8299 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8300 // int -> FLOAT32 map 8301 .float32Operands = {}, 8302 // int -> INT32 map 8303 .int32Operands = {}, 8304 // int -> QUANT8_ASYMM map 8305 .quant8AsymmOperands = {{0, {0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 8306 // int -> QUANT16_SYMM map 8307 .quant16SymmOperands = {}, 8308 // int -> FLOAT16 map 8309 .float16Operands = {}, 8310 // int -> BOOL8 map 8311 .bool8Operands = {}, 8312 // int -> QUANT8_SYMM_PER_CHANNEL map 8313 .quant8ChannelOperands = {}, 8314 // int -> QUANT16_ASYMM map 8315 .quant16AsymmOperands = {}, 8316 // int -> QUANT8_SYMM map 8317 .quant8SymmOperands = {}, 8318 } 8319 }, 8320 }, // End of an example 8321 }; 8322 return examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input; 8323 }; 8324 8325 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_2() { 8326 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_2 = { 8327 // Begin of an example 8328 { 8329 .operands = { 8330 //Input(s) 8331 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8332 // int -> Dimensions map 8333 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8334 // int -> FLOAT32 map 8335 .float32Operands = {}, 8336 // int -> INT32 map 8337 .int32Operands = {}, 8338 // int -> QUANT8_ASYMM map 8339 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 8340 // int -> QUANT16_SYMM map 8341 .quant16SymmOperands = {}, 8342 // int -> FLOAT16 map 8343 .float16Operands = {}, 8344 // int -> BOOL8 map 8345 .bool8Operands = {}, 8346 // int -> QUANT8_SYMM_PER_CHANNEL map 8347 .quant8ChannelOperands = {}, 8348 // int -> QUANT16_ASYMM map 8349 .quant16AsymmOperands = {}, 8350 // int -> QUANT8_SYMM map 8351 .quant8SymmOperands = {}, 8352 }, 8353 //Output(s) 8354 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8355 // int -> Dimensions map 8356 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8357 // int -> FLOAT32 map 8358 .float32Operands = {}, 8359 // int -> INT32 map 8360 .int32Operands = {}, 8361 // int -> QUANT8_ASYMM map 8362 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 8363 // int -> QUANT16_SYMM map 8364 .quant16SymmOperands = {}, 8365 // int -> FLOAT16 map 8366 .float16Operands = {}, 8367 // int -> BOOL8 map 8368 .bool8Operands = {}, 8369 // int -> QUANT8_SYMM_PER_CHANNEL map 8370 .quant8ChannelOperands = {}, 8371 // int -> QUANT16_ASYMM map 8372 .quant16AsymmOperands = {}, 8373 // int -> QUANT8_SYMM map 8374 .quant8SymmOperands = {}, 8375 } 8376 }, 8377 }, // End of an example 8378 }; 8379 return examples_dynamic_output_shape_nhwc_relu1_quant8_2; 8380 }; 8381 8382 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2() { 8383 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2 = { 8384 // Begin of an example 8385 { 8386 .operands = { 8387 //Input(s) 8388 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8389 // int -> Dimensions map 8390 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8391 // int -> FLOAT32 map 8392 .float32Operands = {}, 8393 // int -> INT32 map 8394 .int32Operands = {{2, {-6, -8}}}, 8395 // int -> QUANT8_ASYMM map 8396 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 8397 // int -> QUANT16_SYMM map 8398 .quant16SymmOperands = {}, 8399 // int -> FLOAT16 map 8400 .float16Operands = {}, 8401 // int -> BOOL8 map 8402 .bool8Operands = {}, 8403 // int -> QUANT8_SYMM_PER_CHANNEL map 8404 .quant8ChannelOperands = {}, 8405 // int -> QUANT16_ASYMM map 8406 .quant16AsymmOperands = {}, 8407 // int -> QUANT8_SYMM map 8408 .quant8SymmOperands = {}, 8409 }, 8410 //Output(s) 8411 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8412 // int -> Dimensions map 8413 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8414 // int -> FLOAT32 map 8415 .float32Operands = {}, 8416 // int -> INT32 map 8417 .int32Operands = {}, 8418 // int -> QUANT8_ASYMM map 8419 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 8420 // int -> QUANT16_SYMM map 8421 .quant16SymmOperands = {}, 8422 // int -> FLOAT16 map 8423 .float16Operands = {}, 8424 // int -> BOOL8 map 8425 .bool8Operands = {}, 8426 // int -> QUANT8_SYMM_PER_CHANNEL map 8427 .quant8ChannelOperands = {}, 8428 // int -> QUANT16_ASYMM map 8429 .quant16AsymmOperands = {}, 8430 // int -> QUANT8_SYMM map 8431 .quant8SymmOperands = {}, 8432 } 8433 }, 8434 }, // End of an example 8435 }; 8436 return examples_dynamic_output_shape_nhwc_relu1_quant8_weight_as_input_2; 8437 }; 8438 8439 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8() { 8440 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8 = { 8441 // Begin of an example 8442 { 8443 .operands = { 8444 //Input(s) 8445 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8446 // int -> Dimensions map 8447 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8448 // int -> FLOAT32 map 8449 .float32Operands = {}, 8450 // int -> INT32 map 8451 .int32Operands = {}, 8452 // int -> QUANT8_ASYMM map 8453 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 8454 // int -> QUANT16_SYMM map 8455 .quant16SymmOperands = {}, 8456 // int -> FLOAT16 map 8457 .float16Operands = {}, 8458 // int -> BOOL8 map 8459 .bool8Operands = {}, 8460 // int -> QUANT8_SYMM_PER_CHANNEL map 8461 .quant8ChannelOperands = {}, 8462 // int -> QUANT16_ASYMM map 8463 .quant16AsymmOperands = {}, 8464 // int -> QUANT8_SYMM map 8465 .quant8SymmOperands = {}, 8466 }, 8467 //Output(s) 8468 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8469 // int -> Dimensions map 8470 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8471 // int -> FLOAT32 map 8472 .float32Operands = {}, 8473 // int -> INT32 map 8474 .int32Operands = {}, 8475 // int -> QUANT8_ASYMM map 8476 .quant8AsymmOperands = {{0, {79, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 8477 // int -> QUANT16_SYMM map 8478 .quant16SymmOperands = {}, 8479 // int -> FLOAT16 map 8480 .float16Operands = {}, 8481 // int -> BOOL8 map 8482 .bool8Operands = {}, 8483 // int -> QUANT8_SYMM_PER_CHANNEL map 8484 .quant8ChannelOperands = {}, 8485 // int -> QUANT16_ASYMM map 8486 .quant16AsymmOperands = {}, 8487 // int -> QUANT8_SYMM map 8488 .quant8SymmOperands = {}, 8489 } 8490 }, 8491 }, // End of an example 8492 }; 8493 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8; 8494 }; 8495 8496 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input() { 8497 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input = { 8498 // Begin of an example 8499 { 8500 .operands = { 8501 //Input(s) 8502 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8503 // int -> Dimensions map 8504 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8505 // int -> FLOAT32 map 8506 .float32Operands = {}, 8507 // int -> INT32 map 8508 .int32Operands = {{2, {-24, -16}}}, 8509 // int -> QUANT8_ASYMM map 8510 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 8511 // int -> QUANT16_SYMM map 8512 .quant16SymmOperands = {}, 8513 // int -> FLOAT16 map 8514 .float16Operands = {}, 8515 // int -> BOOL8 map 8516 .bool8Operands = {}, 8517 // int -> QUANT8_SYMM_PER_CHANNEL map 8518 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 8519 // int -> QUANT16_ASYMM map 8520 .quant16AsymmOperands = {}, 8521 // int -> QUANT8_SYMM map 8522 .quant8SymmOperands = {}, 8523 }, 8524 //Output(s) 8525 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8526 // int -> Dimensions map 8527 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8528 // int -> FLOAT32 map 8529 .float32Operands = {}, 8530 // int -> INT32 map 8531 .int32Operands = {}, 8532 // int -> QUANT8_ASYMM map 8533 .quant8AsymmOperands = {{0, {79, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 8534 // int -> QUANT16_SYMM map 8535 .quant16SymmOperands = {}, 8536 // int -> FLOAT16 map 8537 .float16Operands = {}, 8538 // int -> BOOL8 map 8539 .bool8Operands = {}, 8540 // int -> QUANT8_SYMM_PER_CHANNEL map 8541 .quant8ChannelOperands = {}, 8542 // int -> QUANT16_ASYMM map 8543 .quant16AsymmOperands = {}, 8544 // int -> QUANT8_SYMM map 8545 .quant8SymmOperands = {}, 8546 } 8547 }, 8548 }, // End of an example 8549 }; 8550 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input; 8551 }; 8552 8553 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2() { 8554 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2 = { 8555 // Begin of an example 8556 { 8557 .operands = { 8558 //Input(s) 8559 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8560 // int -> Dimensions map 8561 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8562 // int -> FLOAT32 map 8563 .float32Operands = {}, 8564 // int -> INT32 map 8565 .int32Operands = {}, 8566 // int -> QUANT8_ASYMM map 8567 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 8568 // int -> QUANT16_SYMM map 8569 .quant16SymmOperands = {}, 8570 // int -> FLOAT16 map 8571 .float16Operands = {}, 8572 // int -> BOOL8 map 8573 .bool8Operands = {}, 8574 // int -> QUANT8_SYMM_PER_CHANNEL map 8575 .quant8ChannelOperands = {}, 8576 // int -> QUANT16_ASYMM map 8577 .quant16AsymmOperands = {}, 8578 // int -> QUANT8_SYMM map 8579 .quant8SymmOperands = {}, 8580 }, 8581 //Output(s) 8582 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8583 // int -> Dimensions map 8584 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8585 // int -> FLOAT32 map 8586 .float32Operands = {}, 8587 // int -> INT32 map 8588 .int32Operands = {}, 8589 // int -> QUANT8_ASYMM map 8590 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 8591 // int -> QUANT16_SYMM map 8592 .quant16SymmOperands = {}, 8593 // int -> FLOAT16 map 8594 .float16Operands = {}, 8595 // int -> BOOL8 map 8596 .bool8Operands = {}, 8597 // int -> QUANT8_SYMM_PER_CHANNEL map 8598 .quant8ChannelOperands = {}, 8599 // int -> QUANT16_ASYMM map 8600 .quant16AsymmOperands = {}, 8601 // int -> QUANT8_SYMM map 8602 .quant8SymmOperands = {}, 8603 } 8604 }, 8605 }, // End of an example 8606 }; 8607 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_2; 8608 }; 8609 8610 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2() { 8611 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2 = { 8612 // Begin of an example 8613 { 8614 .operands = { 8615 //Input(s) 8616 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8617 // int -> Dimensions map 8618 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8619 // int -> FLOAT32 map 8620 .float32Operands = {}, 8621 // int -> INT32 map 8622 .int32Operands = {{2, {-24, -16}}}, 8623 // int -> QUANT8_ASYMM map 8624 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 8625 // int -> QUANT16_SYMM map 8626 .quant16SymmOperands = {}, 8627 // int -> FLOAT16 map 8628 .float16Operands = {}, 8629 // int -> BOOL8 map 8630 .bool8Operands = {}, 8631 // int -> QUANT8_SYMM_PER_CHANNEL map 8632 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 8633 // int -> QUANT16_ASYMM map 8634 .quant16AsymmOperands = {}, 8635 // int -> QUANT8_SYMM map 8636 .quant8SymmOperands = {}, 8637 }, 8638 //Output(s) 8639 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8640 // int -> Dimensions map 8641 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8642 // int -> FLOAT32 map 8643 .float32Operands = {}, 8644 // int -> INT32 map 8645 .int32Operands = {}, 8646 // int -> QUANT8_ASYMM map 8647 .quant8AsymmOperands = {{0, {75, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 8648 // int -> QUANT16_SYMM map 8649 .quant16SymmOperands = {}, 8650 // int -> FLOAT16 map 8651 .float16Operands = {}, 8652 // int -> BOOL8 map 8653 .bool8Operands = {}, 8654 // int -> QUANT8_SYMM_PER_CHANNEL map 8655 .quant8ChannelOperands = {}, 8656 // int -> QUANT16_ASYMM map 8657 .quant16AsymmOperands = {}, 8658 // int -> QUANT8_SYMM map 8659 .quant8SymmOperands = {}, 8660 } 8661 }, 8662 }, // End of an example 8663 }; 8664 return examples_dynamic_output_shape_nhwc_relu1_channelQuant8_weight_as_input_2; 8665 }; 8666 8667 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_float16() { 8668 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_float16 = { 8669 // Begin of an example 8670 { 8671 .operands = { 8672 //Input(s) 8673 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8674 // int -> Dimensions map 8675 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8676 // int -> FLOAT32 map 8677 .float32Operands = {}, 8678 // int -> INT32 map 8679 .int32Operands = {}, 8680 // int -> QUANT8_ASYMM map 8681 .quant8AsymmOperands = {}, 8682 // int -> QUANT16_SYMM map 8683 .quant16SymmOperands = {}, 8684 // int -> FLOAT16 map 8685 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 8686 // int -> BOOL8 map 8687 .bool8Operands = {}, 8688 // int -> QUANT8_SYMM_PER_CHANNEL map 8689 .quant8ChannelOperands = {}, 8690 // int -> QUANT16_ASYMM map 8691 .quant16AsymmOperands = {}, 8692 // int -> QUANT8_SYMM map 8693 .quant8SymmOperands = {}, 8694 }, 8695 //Output(s) 8696 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8697 // int -> Dimensions map 8698 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8699 // int -> FLOAT32 map 8700 .float32Operands = {}, 8701 // int -> INT32 map 8702 .int32Operands = {}, 8703 // int -> QUANT8_ASYMM map 8704 .quant8AsymmOperands = {}, 8705 // int -> QUANT16_SYMM map 8706 .quant16SymmOperands = {}, 8707 // int -> FLOAT16 map 8708 .float16Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8709 // int -> BOOL8 map 8710 .bool8Operands = {}, 8711 // int -> QUANT8_SYMM_PER_CHANNEL map 8712 .quant8ChannelOperands = {}, 8713 // int -> QUANT16_ASYMM map 8714 .quant16AsymmOperands = {}, 8715 // int -> QUANT8_SYMM map 8716 .quant8SymmOperands = {}, 8717 } 8718 }, 8719 }, // End of an example 8720 }; 8721 return examples_dynamic_output_shape_nhwc_relu1_float16; 8722 }; 8723 8724 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input() { 8725 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input = { 8726 // Begin of an example 8727 { 8728 .operands = { 8729 //Input(s) 8730 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8731 // int -> Dimensions map 8732 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8733 // int -> FLOAT32 map 8734 .float32Operands = {}, 8735 // int -> INT32 map 8736 .int32Operands = {}, 8737 // int -> QUANT8_ASYMM map 8738 .quant8AsymmOperands = {}, 8739 // int -> QUANT16_SYMM map 8740 .quant16SymmOperands = {}, 8741 // int -> FLOAT16 map 8742 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 8743 // int -> BOOL8 map 8744 .bool8Operands = {}, 8745 // int -> QUANT8_SYMM_PER_CHANNEL map 8746 .quant8ChannelOperands = {}, 8747 // int -> QUANT16_ASYMM map 8748 .quant16AsymmOperands = {}, 8749 // int -> QUANT8_SYMM map 8750 .quant8SymmOperands = {}, 8751 }, 8752 //Output(s) 8753 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8754 // int -> Dimensions map 8755 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8756 // int -> FLOAT32 map 8757 .float32Operands = {}, 8758 // int -> INT32 map 8759 .int32Operands = {}, 8760 // int -> QUANT8_ASYMM map 8761 .quant8AsymmOperands = {}, 8762 // int -> QUANT16_SYMM map 8763 .quant16SymmOperands = {}, 8764 // int -> FLOAT16 map 8765 .float16Operands = {{0, {-0.5f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 8766 // int -> BOOL8 map 8767 .bool8Operands = {}, 8768 // int -> QUANT8_SYMM_PER_CHANNEL map 8769 .quant8ChannelOperands = {}, 8770 // int -> QUANT16_ASYMM map 8771 .quant16AsymmOperands = {}, 8772 // int -> QUANT8_SYMM map 8773 .quant8SymmOperands = {}, 8774 } 8775 }, 8776 }, // End of an example 8777 }; 8778 return examples_dynamic_output_shape_nhwc_relu1_float16_weight_as_input; 8779 }; 8780 8781 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6() { 8782 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6 = { 8783 // Begin of an example 8784 { 8785 .operands = { 8786 //Input(s) 8787 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8788 // int -> Dimensions map 8789 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8790 // int -> FLOAT32 map 8791 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 8792 // int -> INT32 map 8793 .int32Operands = {}, 8794 // int -> QUANT8_ASYMM map 8795 .quant8AsymmOperands = {}, 8796 // int -> QUANT16_SYMM map 8797 .quant16SymmOperands = {}, 8798 // int -> FLOAT16 map 8799 .float16Operands = {}, 8800 // int -> BOOL8 map 8801 .bool8Operands = {}, 8802 // int -> QUANT8_SYMM_PER_CHANNEL map 8803 .quant8ChannelOperands = {}, 8804 // int -> QUANT16_ASYMM map 8805 .quant16AsymmOperands = {}, 8806 // int -> QUANT8_SYMM map 8807 .quant8SymmOperands = {}, 8808 }, 8809 //Output(s) 8810 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8811 // int -> Dimensions map 8812 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8813 // int -> FLOAT32 map 8814 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 8815 // int -> INT32 map 8816 .int32Operands = {}, 8817 // int -> QUANT8_ASYMM map 8818 .quant8AsymmOperands = {}, 8819 // int -> QUANT16_SYMM map 8820 .quant16SymmOperands = {}, 8821 // int -> FLOAT16 map 8822 .float16Operands = {}, 8823 // int -> BOOL8 map 8824 .bool8Operands = {}, 8825 // int -> QUANT8_SYMM_PER_CHANNEL map 8826 .quant8ChannelOperands = {}, 8827 // int -> QUANT16_ASYMM map 8828 .quant16AsymmOperands = {}, 8829 // int -> QUANT8_SYMM map 8830 .quant8SymmOperands = {}, 8831 } 8832 }, 8833 }, // End of an example 8834 }; 8835 return examples_dynamic_output_shape_nhwc_relu6; 8836 }; 8837 8838 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_weight_as_input() { 8839 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_weight_as_input = { 8840 // Begin of an example 8841 { 8842 .operands = { 8843 //Input(s) 8844 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8845 // int -> Dimensions map 8846 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8847 // int -> FLOAT32 map 8848 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 8849 // int -> INT32 map 8850 .int32Operands = {}, 8851 // int -> QUANT8_ASYMM map 8852 .quant8AsymmOperands = {}, 8853 // int -> QUANT16_SYMM map 8854 .quant16SymmOperands = {}, 8855 // int -> FLOAT16 map 8856 .float16Operands = {}, 8857 // int -> BOOL8 map 8858 .bool8Operands = {}, 8859 // int -> QUANT8_SYMM_PER_CHANNEL map 8860 .quant8ChannelOperands = {}, 8861 // int -> QUANT16_ASYMM map 8862 .quant16AsymmOperands = {}, 8863 // int -> QUANT8_SYMM map 8864 .quant8SymmOperands = {}, 8865 }, 8866 //Output(s) 8867 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8868 // int -> Dimensions map 8869 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8870 // int -> FLOAT32 map 8871 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 8872 // int -> INT32 map 8873 .int32Operands = {}, 8874 // int -> QUANT8_ASYMM map 8875 .quant8AsymmOperands = {}, 8876 // int -> QUANT16_SYMM map 8877 .quant16SymmOperands = {}, 8878 // int -> FLOAT16 map 8879 .float16Operands = {}, 8880 // int -> BOOL8 map 8881 .bool8Operands = {}, 8882 // int -> QUANT8_SYMM_PER_CHANNEL map 8883 .quant8ChannelOperands = {}, 8884 // int -> QUANT16_ASYMM map 8885 .quant16AsymmOperands = {}, 8886 // int -> QUANT8_SYMM map 8887 .quant8SymmOperands = {}, 8888 } 8889 }, 8890 }, // End of an example 8891 }; 8892 return examples_dynamic_output_shape_nhwc_relu6_weight_as_input; 8893 }; 8894 8895 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_relaxed() { 8896 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_relaxed = { 8897 // Begin of an example 8898 { 8899 .operands = { 8900 //Input(s) 8901 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8902 // int -> Dimensions map 8903 .operandDimensions = {{0, {1, 2, 2, 1}}}, 8904 // int -> FLOAT32 map 8905 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 8906 // int -> INT32 map 8907 .int32Operands = {}, 8908 // int -> QUANT8_ASYMM map 8909 .quant8AsymmOperands = {}, 8910 // int -> QUANT16_SYMM map 8911 .quant16SymmOperands = {}, 8912 // int -> FLOAT16 map 8913 .float16Operands = {}, 8914 // int -> BOOL8 map 8915 .bool8Operands = {}, 8916 // int -> QUANT8_SYMM_PER_CHANNEL map 8917 .quant8ChannelOperands = {}, 8918 // int -> QUANT16_ASYMM map 8919 .quant16AsymmOperands = {}, 8920 // int -> QUANT8_SYMM map 8921 .quant8SymmOperands = {}, 8922 }, 8923 //Output(s) 8924 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8925 // int -> Dimensions map 8926 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8927 // int -> FLOAT32 map 8928 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 8929 // int -> INT32 map 8930 .int32Operands = {}, 8931 // int -> QUANT8_ASYMM map 8932 .quant8AsymmOperands = {}, 8933 // int -> QUANT16_SYMM map 8934 .quant16SymmOperands = {}, 8935 // int -> FLOAT16 map 8936 .float16Operands = {}, 8937 // int -> BOOL8 map 8938 .bool8Operands = {}, 8939 // int -> QUANT8_SYMM_PER_CHANNEL map 8940 .quant8ChannelOperands = {}, 8941 // int -> QUANT16_ASYMM map 8942 .quant16AsymmOperands = {}, 8943 // int -> QUANT8_SYMM map 8944 .quant8SymmOperands = {}, 8945 } 8946 }, 8947 }, // End of an example 8948 }; 8949 return examples_dynamic_output_shape_nhwc_relu6_relaxed; 8950 }; 8951 8952 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input() { 8953 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input = { 8954 // Begin of an example 8955 { 8956 .operands = { 8957 //Input(s) 8958 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8959 // int -> Dimensions map 8960 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 8961 // int -> FLOAT32 map 8962 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 8963 // int -> INT32 map 8964 .int32Operands = {}, 8965 // int -> QUANT8_ASYMM map 8966 .quant8AsymmOperands = {}, 8967 // int -> QUANT16_SYMM map 8968 .quant16SymmOperands = {}, 8969 // int -> FLOAT16 map 8970 .float16Operands = {}, 8971 // int -> BOOL8 map 8972 .bool8Operands = {}, 8973 // int -> QUANT8_SYMM_PER_CHANNEL map 8974 .quant8ChannelOperands = {}, 8975 // int -> QUANT16_ASYMM map 8976 .quant16AsymmOperands = {}, 8977 // int -> QUANT8_SYMM map 8978 .quant8SymmOperands = {}, 8979 }, 8980 //Output(s) 8981 { // See tools/test_generator/include/TestHarness.h:MixedTyped 8982 // int -> Dimensions map 8983 .operandDimensions = {{0, {1, 5, 5, 2}}}, 8984 // int -> FLOAT32 map 8985 .float32Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 8986 // int -> INT32 map 8987 .int32Operands = {}, 8988 // int -> QUANT8_ASYMM map 8989 .quant8AsymmOperands = {}, 8990 // int -> QUANT16_SYMM map 8991 .quant16SymmOperands = {}, 8992 // int -> FLOAT16 map 8993 .float16Operands = {}, 8994 // int -> BOOL8 map 8995 .bool8Operands = {}, 8996 // int -> QUANT8_SYMM_PER_CHANNEL map 8997 .quant8ChannelOperands = {}, 8998 // int -> QUANT16_ASYMM map 8999 .quant16AsymmOperands = {}, 9000 // int -> QUANT8_SYMM map 9001 .quant8SymmOperands = {}, 9002 } 9003 }, 9004 }, // End of an example 9005 }; 9006 return examples_dynamic_output_shape_nhwc_relu6_relaxed_weight_as_input; 9007 }; 9008 9009 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8() { 9010 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8 = { 9011 // Begin of an example 9012 { 9013 .operands = { 9014 //Input(s) 9015 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9016 // int -> Dimensions map 9017 .operandDimensions = {{0, {1, 2, 2, 1}}}, 9018 // int -> FLOAT32 map 9019 .float32Operands = {}, 9020 // int -> INT32 map 9021 .int32Operands = {}, 9022 // int -> QUANT8_ASYMM map 9023 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 9024 // int -> QUANT16_SYMM map 9025 .quant16SymmOperands = {}, 9026 // int -> FLOAT16 map 9027 .float16Operands = {}, 9028 // int -> BOOL8 map 9029 .bool8Operands = {}, 9030 // int -> QUANT8_SYMM_PER_CHANNEL map 9031 .quant8ChannelOperands = {}, 9032 // int -> QUANT16_ASYMM map 9033 .quant16AsymmOperands = {}, 9034 // int -> QUANT8_SYMM map 9035 .quant8SymmOperands = {}, 9036 }, 9037 //Output(s) 9038 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9039 // int -> Dimensions map 9040 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9041 // int -> FLOAT32 map 9042 .float32Operands = {}, 9043 // int -> INT32 map 9044 .int32Operands = {}, 9045 // int -> QUANT8_ASYMM map 9046 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 12, 9, 12, 12, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 9047 // int -> QUANT16_SYMM map 9048 .quant16SymmOperands = {}, 9049 // int -> FLOAT16 map 9050 .float16Operands = {}, 9051 // int -> BOOL8 map 9052 .bool8Operands = {}, 9053 // int -> QUANT8_SYMM_PER_CHANNEL map 9054 .quant8ChannelOperands = {}, 9055 // int -> QUANT16_ASYMM map 9056 .quant16AsymmOperands = {}, 9057 // int -> QUANT8_SYMM map 9058 .quant8SymmOperands = {}, 9059 } 9060 }, 9061 }, // End of an example 9062 }; 9063 return examples_dynamic_output_shape_nhwc_relu6_quant8; 9064 }; 9065 9066 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input() { 9067 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input = { 9068 // Begin of an example 9069 { 9070 .operands = { 9071 //Input(s) 9072 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9073 // int -> Dimensions map 9074 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9075 // int -> FLOAT32 map 9076 .float32Operands = {}, 9077 // int -> INT32 map 9078 .int32Operands = {{2, {-6, -8}}}, 9079 // int -> QUANT8_ASYMM map 9080 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 9081 // int -> QUANT16_SYMM map 9082 .quant16SymmOperands = {}, 9083 // int -> FLOAT16 map 9084 .float16Operands = {}, 9085 // int -> BOOL8 map 9086 .bool8Operands = {}, 9087 // int -> QUANT8_SYMM_PER_CHANNEL map 9088 .quant8ChannelOperands = {}, 9089 // int -> QUANT16_ASYMM map 9090 .quant16AsymmOperands = {}, 9091 // int -> QUANT8_SYMM map 9092 .quant8SymmOperands = {}, 9093 }, 9094 //Output(s) 9095 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9096 // int -> Dimensions map 9097 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9098 // int -> FLOAT32 map 9099 .float32Operands = {}, 9100 // int -> INT32 map 9101 .int32Operands = {}, 9102 // int -> QUANT8_ASYMM map 9103 .quant8AsymmOperands = {{0, {0, 0, 3, 4, 11, 12, 9, 12, 12, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 9104 // int -> QUANT16_SYMM map 9105 .quant16SymmOperands = {}, 9106 // int -> FLOAT16 map 9107 .float16Operands = {}, 9108 // int -> BOOL8 map 9109 .bool8Operands = {}, 9110 // int -> QUANT8_SYMM_PER_CHANNEL map 9111 .quant8ChannelOperands = {}, 9112 // int -> QUANT16_ASYMM map 9113 .quant16AsymmOperands = {}, 9114 // int -> QUANT8_SYMM map 9115 .quant8SymmOperands = {}, 9116 } 9117 }, 9118 }, // End of an example 9119 }; 9120 return examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input; 9121 }; 9122 9123 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_2() { 9124 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_2 = { 9125 // Begin of an example 9126 { 9127 .operands = { 9128 //Input(s) 9129 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9130 // int -> Dimensions map 9131 .operandDimensions = {{0, {1, 2, 2, 1}}}, 9132 // int -> FLOAT32 map 9133 .float32Operands = {}, 9134 // int -> INT32 map 9135 .int32Operands = {}, 9136 // int -> QUANT8_ASYMM map 9137 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 9138 // int -> QUANT16_SYMM map 9139 .quant16SymmOperands = {}, 9140 // int -> FLOAT16 map 9141 .float16Operands = {}, 9142 // int -> BOOL8 map 9143 .bool8Operands = {}, 9144 // int -> QUANT8_SYMM_PER_CHANNEL map 9145 .quant8ChannelOperands = {}, 9146 // int -> QUANT16_ASYMM map 9147 .quant16AsymmOperands = {}, 9148 // int -> QUANT8_SYMM map 9149 .quant8SymmOperands = {}, 9150 }, 9151 //Output(s) 9152 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9153 // int -> Dimensions map 9154 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9155 // int -> FLOAT32 map 9156 .float32Operands = {}, 9157 // int -> INT32 map 9158 .int32Operands = {}, 9159 // int -> QUANT8_ASYMM map 9160 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 9161 // int -> QUANT16_SYMM map 9162 .quant16SymmOperands = {}, 9163 // int -> FLOAT16 map 9164 .float16Operands = {}, 9165 // int -> BOOL8 map 9166 .bool8Operands = {}, 9167 // int -> QUANT8_SYMM_PER_CHANNEL map 9168 .quant8ChannelOperands = {}, 9169 // int -> QUANT16_ASYMM map 9170 .quant16AsymmOperands = {}, 9171 // int -> QUANT8_SYMM map 9172 .quant8SymmOperands = {}, 9173 } 9174 }, 9175 }, // End of an example 9176 }; 9177 return examples_dynamic_output_shape_nhwc_relu6_quant8_2; 9178 }; 9179 9180 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2() { 9181 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2 = { 9182 // Begin of an example 9183 { 9184 .operands = { 9185 //Input(s) 9186 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9187 // int -> Dimensions map 9188 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9189 // int -> FLOAT32 map 9190 .float32Operands = {}, 9191 // int -> INT32 map 9192 .int32Operands = {{2, {-6, -8}}}, 9193 // int -> QUANT8_ASYMM map 9194 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 9195 // int -> QUANT16_SYMM map 9196 .quant16SymmOperands = {}, 9197 // int -> FLOAT16 map 9198 .float16Operands = {}, 9199 // int -> BOOL8 map 9200 .bool8Operands = {}, 9201 // int -> QUANT8_SYMM_PER_CHANNEL map 9202 .quant8ChannelOperands = {}, 9203 // int -> QUANT16_ASYMM map 9204 .quant16AsymmOperands = {}, 9205 // int -> QUANT8_SYMM map 9206 .quant8SymmOperands = {}, 9207 }, 9208 //Output(s) 9209 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9210 // int -> Dimensions map 9211 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9212 // int -> FLOAT32 map 9213 .float32Operands = {}, 9214 // int -> INT32 map 9215 .int32Operands = {}, 9216 // int -> QUANT8_ASYMM map 9217 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 9218 // int -> QUANT16_SYMM map 9219 .quant16SymmOperands = {}, 9220 // int -> FLOAT16 map 9221 .float16Operands = {}, 9222 // int -> BOOL8 map 9223 .bool8Operands = {}, 9224 // int -> QUANT8_SYMM_PER_CHANNEL map 9225 .quant8ChannelOperands = {}, 9226 // int -> QUANT16_ASYMM map 9227 .quant16AsymmOperands = {}, 9228 // int -> QUANT8_SYMM map 9229 .quant8SymmOperands = {}, 9230 } 9231 }, 9232 }, // End of an example 9233 }; 9234 return examples_dynamic_output_shape_nhwc_relu6_quant8_weight_as_input_2; 9235 }; 9236 9237 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8() { 9238 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8 = { 9239 // Begin of an example 9240 { 9241 .operands = { 9242 //Input(s) 9243 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9244 // int -> Dimensions map 9245 .operandDimensions = {{0, {1, 2, 2, 1}}}, 9246 // int -> FLOAT32 map 9247 .float32Operands = {}, 9248 // int -> INT32 map 9249 .int32Operands = {}, 9250 // int -> QUANT8_ASYMM map 9251 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 9252 // int -> QUANT16_SYMM map 9253 .quant16SymmOperands = {}, 9254 // int -> FLOAT16 map 9255 .float16Operands = {}, 9256 // int -> BOOL8 map 9257 .bool8Operands = {}, 9258 // int -> QUANT8_SYMM_PER_CHANNEL map 9259 .quant8ChannelOperands = {}, 9260 // int -> QUANT16_ASYMM map 9261 .quant16AsymmOperands = {}, 9262 // int -> QUANT8_SYMM map 9263 .quant8SymmOperands = {}, 9264 }, 9265 //Output(s) 9266 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9267 // int -> Dimensions map 9268 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9269 // int -> FLOAT32 map 9270 .float32Operands = {}, 9271 // int -> INT32 map 9272 .int32Operands = {}, 9273 // int -> QUANT8_ASYMM map 9274 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 92, 89, 92, 92, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 9275 // int -> QUANT16_SYMM map 9276 .quant16SymmOperands = {}, 9277 // int -> FLOAT16 map 9278 .float16Operands = {}, 9279 // int -> BOOL8 map 9280 .bool8Operands = {}, 9281 // int -> QUANT8_SYMM_PER_CHANNEL map 9282 .quant8ChannelOperands = {}, 9283 // int -> QUANT16_ASYMM map 9284 .quant16AsymmOperands = {}, 9285 // int -> QUANT8_SYMM map 9286 .quant8SymmOperands = {}, 9287 } 9288 }, 9289 }, // End of an example 9290 }; 9291 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8; 9292 }; 9293 9294 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input() { 9295 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input = { 9296 // Begin of an example 9297 { 9298 .operands = { 9299 //Input(s) 9300 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9301 // int -> Dimensions map 9302 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9303 // int -> FLOAT32 map 9304 .float32Operands = {}, 9305 // int -> INT32 map 9306 .int32Operands = {{2, {-24, -16}}}, 9307 // int -> QUANT8_ASYMM map 9308 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 9309 // int -> QUANT16_SYMM map 9310 .quant16SymmOperands = {}, 9311 // int -> FLOAT16 map 9312 .float16Operands = {}, 9313 // int -> BOOL8 map 9314 .bool8Operands = {}, 9315 // int -> QUANT8_SYMM_PER_CHANNEL map 9316 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 9317 // int -> QUANT16_ASYMM map 9318 .quant16AsymmOperands = {}, 9319 // int -> QUANT8_SYMM map 9320 .quant8SymmOperands = {}, 9321 }, 9322 //Output(s) 9323 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9324 // int -> Dimensions map 9325 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9326 // int -> FLOAT32 map 9327 .float32Operands = {}, 9328 // int -> INT32 map 9329 .int32Operands = {}, 9330 // int -> QUANT8_ASYMM map 9331 .quant8AsymmOperands = {{0, {80, 80, 83, 84, 91, 92, 89, 92, 92, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 9332 // int -> QUANT16_SYMM map 9333 .quant16SymmOperands = {}, 9334 // int -> FLOAT16 map 9335 .float16Operands = {}, 9336 // int -> BOOL8 map 9337 .bool8Operands = {}, 9338 // int -> QUANT8_SYMM_PER_CHANNEL map 9339 .quant8ChannelOperands = {}, 9340 // int -> QUANT16_ASYMM map 9341 .quant16AsymmOperands = {}, 9342 // int -> QUANT8_SYMM map 9343 .quant8SymmOperands = {}, 9344 } 9345 }, 9346 }, // End of an example 9347 }; 9348 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input; 9349 }; 9350 9351 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2() { 9352 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2 = { 9353 // Begin of an example 9354 { 9355 .operands = { 9356 //Input(s) 9357 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9358 // int -> Dimensions map 9359 .operandDimensions = {{0, {1, 2, 2, 1}}}, 9360 // int -> FLOAT32 map 9361 .float32Operands = {}, 9362 // int -> INT32 map 9363 .int32Operands = {}, 9364 // int -> QUANT8_ASYMM map 9365 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 9366 // int -> QUANT16_SYMM map 9367 .quant16SymmOperands = {}, 9368 // int -> FLOAT16 map 9369 .float16Operands = {}, 9370 // int -> BOOL8 map 9371 .bool8Operands = {}, 9372 // int -> QUANT8_SYMM_PER_CHANNEL map 9373 .quant8ChannelOperands = {}, 9374 // int -> QUANT16_ASYMM map 9375 .quant16AsymmOperands = {}, 9376 // int -> QUANT8_SYMM map 9377 .quant8SymmOperands = {}, 9378 }, 9379 //Output(s) 9380 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9381 // int -> Dimensions map 9382 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9383 // int -> FLOAT32 map 9384 .float32Operands = {}, 9385 // int -> INT32 map 9386 .int32Operands = {}, 9387 // int -> QUANT8_ASYMM map 9388 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 9389 // int -> QUANT16_SYMM map 9390 .quant16SymmOperands = {}, 9391 // int -> FLOAT16 map 9392 .float16Operands = {}, 9393 // int -> BOOL8 map 9394 .bool8Operands = {}, 9395 // int -> QUANT8_SYMM_PER_CHANNEL map 9396 .quant8ChannelOperands = {}, 9397 // int -> QUANT16_ASYMM map 9398 .quant16AsymmOperands = {}, 9399 // int -> QUANT8_SYMM map 9400 .quant8SymmOperands = {}, 9401 } 9402 }, 9403 }, // End of an example 9404 }; 9405 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_2; 9406 }; 9407 9408 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2() { 9409 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2 = { 9410 // Begin of an example 9411 { 9412 .operands = { 9413 //Input(s) 9414 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9415 // int -> Dimensions map 9416 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9417 // int -> FLOAT32 map 9418 .float32Operands = {}, 9419 // int -> INT32 map 9420 .int32Operands = {{2, {-24, -16}}}, 9421 // int -> QUANT8_ASYMM map 9422 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 9423 // int -> QUANT16_SYMM map 9424 .quant16SymmOperands = {}, 9425 // int -> FLOAT16 map 9426 .float16Operands = {}, 9427 // int -> BOOL8 map 9428 .bool8Operands = {}, 9429 // int -> QUANT8_SYMM_PER_CHANNEL map 9430 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 9431 // int -> QUANT16_ASYMM map 9432 .quant16AsymmOperands = {}, 9433 // int -> QUANT8_SYMM map 9434 .quant8SymmOperands = {}, 9435 }, 9436 //Output(s) 9437 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9438 // int -> Dimensions map 9439 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9440 // int -> FLOAT32 map 9441 .float32Operands = {}, 9442 // int -> INT32 map 9443 .int32Operands = {}, 9444 // int -> QUANT8_ASYMM map 9445 .quant8AsymmOperands = {{0, {80, 80, 95, 100, 135, 140, 125, 140, 140, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 9446 // int -> QUANT16_SYMM map 9447 .quant16SymmOperands = {}, 9448 // int -> FLOAT16 map 9449 .float16Operands = {}, 9450 // int -> BOOL8 map 9451 .bool8Operands = {}, 9452 // int -> QUANT8_SYMM_PER_CHANNEL map 9453 .quant8ChannelOperands = {}, 9454 // int -> QUANT16_ASYMM map 9455 .quant16AsymmOperands = {}, 9456 // int -> QUANT8_SYMM map 9457 .quant8SymmOperands = {}, 9458 } 9459 }, 9460 }, // End of an example 9461 }; 9462 return examples_dynamic_output_shape_nhwc_relu6_channelQuant8_weight_as_input_2; 9463 }; 9464 9465 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_float16() { 9466 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_float16 = { 9467 // Begin of an example 9468 { 9469 .operands = { 9470 //Input(s) 9471 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9472 // int -> Dimensions map 9473 .operandDimensions = {{0, {1, 2, 2, 1}}}, 9474 // int -> FLOAT32 map 9475 .float32Operands = {}, 9476 // int -> INT32 map 9477 .int32Operands = {}, 9478 // int -> QUANT8_ASYMM map 9479 .quant8AsymmOperands = {}, 9480 // int -> QUANT16_SYMM map 9481 .quant16SymmOperands = {}, 9482 // int -> FLOAT16 map 9483 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 9484 // int -> BOOL8 map 9485 .bool8Operands = {}, 9486 // int -> QUANT8_SYMM_PER_CHANNEL map 9487 .quant8ChannelOperands = {}, 9488 // int -> QUANT16_ASYMM map 9489 .quant16AsymmOperands = {}, 9490 // int -> QUANT8_SYMM map 9491 .quant8SymmOperands = {}, 9492 }, 9493 //Output(s) 9494 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9495 // int -> Dimensions map 9496 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9497 // int -> FLOAT32 map 9498 .float32Operands = {}, 9499 // int -> INT32 map 9500 .int32Operands = {}, 9501 // int -> QUANT8_ASYMM map 9502 .quant8AsymmOperands = {}, 9503 // int -> QUANT16_SYMM map 9504 .quant16SymmOperands = {}, 9505 // int -> FLOAT16 map 9506 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 9507 // int -> BOOL8 map 9508 .bool8Operands = {}, 9509 // int -> QUANT8_SYMM_PER_CHANNEL map 9510 .quant8ChannelOperands = {}, 9511 // int -> QUANT16_ASYMM map 9512 .quant16AsymmOperands = {}, 9513 // int -> QUANT8_SYMM map 9514 .quant8SymmOperands = {}, 9515 } 9516 }, 9517 }, // End of an example 9518 }; 9519 return examples_dynamic_output_shape_nhwc_relu6_float16; 9520 }; 9521 9522 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input() { 9523 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input = { 9524 // Begin of an example 9525 { 9526 .operands = { 9527 //Input(s) 9528 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9529 // int -> Dimensions map 9530 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9531 // int -> FLOAT32 map 9532 .float32Operands = {}, 9533 // int -> INT32 map 9534 .int32Operands = {}, 9535 // int -> QUANT8_ASYMM map 9536 .quant8AsymmOperands = {}, 9537 // int -> QUANT16_SYMM map 9538 .quant16SymmOperands = {}, 9539 // int -> FLOAT16 map 9540 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 9541 // int -> BOOL8 map 9542 .bool8Operands = {}, 9543 // int -> QUANT8_SYMM_PER_CHANNEL map 9544 .quant8ChannelOperands = {}, 9545 // int -> QUANT16_ASYMM map 9546 .quant16AsymmOperands = {}, 9547 // int -> QUANT8_SYMM map 9548 .quant8SymmOperands = {}, 9549 }, 9550 //Output(s) 9551 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9552 // int -> Dimensions map 9553 .operandDimensions = {{0, {1, 5, 5, 2}}}, 9554 // int -> FLOAT32 map 9555 .float32Operands = {}, 9556 // int -> INT32 map 9557 .int32Operands = {}, 9558 // int -> QUANT8_ASYMM map 9559 .quant8AsymmOperands = {}, 9560 // int -> QUANT16_SYMM map 9561 .quant16SymmOperands = {}, 9562 // int -> FLOAT16 map 9563 .float16Operands = {{0, {0.0f, 0.0f, 1.5f, 2.0f, 5.5f, 6.0f, 4.5f, 6.0f, 6.0f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 9564 // int -> BOOL8 map 9565 .bool8Operands = {}, 9566 // int -> QUANT8_SYMM_PER_CHANNEL map 9567 .quant8ChannelOperands = {}, 9568 // int -> QUANT16_ASYMM map 9569 .quant16AsymmOperands = {}, 9570 // int -> QUANT8_SYMM map 9571 .quant8SymmOperands = {}, 9572 } 9573 }, 9574 }, // End of an example 9575 }; 9576 return examples_dynamic_output_shape_nhwc_relu6_float16_weight_as_input; 9577 }; 9578 9579 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none() { 9580 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none = { 9581 // Begin of an example 9582 { 9583 .operands = { 9584 //Input(s) 9585 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9586 // int -> Dimensions map 9587 .operandDimensions = {{0, {1, 1, 2, 2}}}, 9588 // int -> FLOAT32 map 9589 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 9590 // int -> INT32 map 9591 .int32Operands = {}, 9592 // int -> QUANT8_ASYMM map 9593 .quant8AsymmOperands = {}, 9594 // int -> QUANT16_SYMM map 9595 .quant16SymmOperands = {}, 9596 // int -> FLOAT16 map 9597 .float16Operands = {}, 9598 // int -> BOOL8 map 9599 .bool8Operands = {}, 9600 // int -> QUANT8_SYMM_PER_CHANNEL map 9601 .quant8ChannelOperands = {}, 9602 // int -> QUANT16_ASYMM map 9603 .quant16AsymmOperands = {}, 9604 // int -> QUANT8_SYMM map 9605 .quant8SymmOperands = {}, 9606 }, 9607 //Output(s) 9608 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9609 // int -> Dimensions map 9610 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9611 // int -> FLOAT32 map 9612 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 9613 // int -> INT32 map 9614 .int32Operands = {}, 9615 // int -> QUANT8_ASYMM map 9616 .quant8AsymmOperands = {}, 9617 // int -> QUANT16_SYMM map 9618 .quant16SymmOperands = {}, 9619 // int -> FLOAT16 map 9620 .float16Operands = {}, 9621 // int -> BOOL8 map 9622 .bool8Operands = {}, 9623 // int -> QUANT8_SYMM_PER_CHANNEL map 9624 .quant8ChannelOperands = {}, 9625 // int -> QUANT16_ASYMM map 9626 .quant16AsymmOperands = {}, 9627 // int -> QUANT8_SYMM map 9628 .quant8SymmOperands = {}, 9629 } 9630 }, 9631 }, // End of an example 9632 }; 9633 return examples_dynamic_output_shape_nchw_none; 9634 }; 9635 9636 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_weight_as_input() { 9637 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_weight_as_input = { 9638 // Begin of an example 9639 { 9640 .operands = { 9641 //Input(s) 9642 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9643 // int -> Dimensions map 9644 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9645 // int -> FLOAT32 map 9646 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 9647 // int -> INT32 map 9648 .int32Operands = {}, 9649 // int -> QUANT8_ASYMM map 9650 .quant8AsymmOperands = {}, 9651 // int -> QUANT16_SYMM map 9652 .quant16SymmOperands = {}, 9653 // int -> FLOAT16 map 9654 .float16Operands = {}, 9655 // int -> BOOL8 map 9656 .bool8Operands = {}, 9657 // int -> QUANT8_SYMM_PER_CHANNEL map 9658 .quant8ChannelOperands = {}, 9659 // int -> QUANT16_ASYMM map 9660 .quant16AsymmOperands = {}, 9661 // int -> QUANT8_SYMM map 9662 .quant8SymmOperands = {}, 9663 }, 9664 //Output(s) 9665 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9666 // int -> Dimensions map 9667 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9668 // int -> FLOAT32 map 9669 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 9670 // int -> INT32 map 9671 .int32Operands = {}, 9672 // int -> QUANT8_ASYMM map 9673 .quant8AsymmOperands = {}, 9674 // int -> QUANT16_SYMM map 9675 .quant16SymmOperands = {}, 9676 // int -> FLOAT16 map 9677 .float16Operands = {}, 9678 // int -> BOOL8 map 9679 .bool8Operands = {}, 9680 // int -> QUANT8_SYMM_PER_CHANNEL map 9681 .quant8ChannelOperands = {}, 9682 // int -> QUANT16_ASYMM map 9683 .quant16AsymmOperands = {}, 9684 // int -> QUANT8_SYMM map 9685 .quant8SymmOperands = {}, 9686 } 9687 }, 9688 }, // End of an example 9689 }; 9690 return examples_dynamic_output_shape_nchw_none_weight_as_input; 9691 }; 9692 9693 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_relaxed() { 9694 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_relaxed = { 9695 // Begin of an example 9696 { 9697 .operands = { 9698 //Input(s) 9699 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9700 // int -> Dimensions map 9701 .operandDimensions = {{0, {1, 1, 2, 2}}}, 9702 // int -> FLOAT32 map 9703 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 9704 // int -> INT32 map 9705 .int32Operands = {}, 9706 // int -> QUANT8_ASYMM map 9707 .quant8AsymmOperands = {}, 9708 // int -> QUANT16_SYMM map 9709 .quant16SymmOperands = {}, 9710 // int -> FLOAT16 map 9711 .float16Operands = {}, 9712 // int -> BOOL8 map 9713 .bool8Operands = {}, 9714 // int -> QUANT8_SYMM_PER_CHANNEL map 9715 .quant8ChannelOperands = {}, 9716 // int -> QUANT16_ASYMM map 9717 .quant16AsymmOperands = {}, 9718 // int -> QUANT8_SYMM map 9719 .quant8SymmOperands = {}, 9720 }, 9721 //Output(s) 9722 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9723 // int -> Dimensions map 9724 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9725 // int -> FLOAT32 map 9726 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 9727 // int -> INT32 map 9728 .int32Operands = {}, 9729 // int -> QUANT8_ASYMM map 9730 .quant8AsymmOperands = {}, 9731 // int -> QUANT16_SYMM map 9732 .quant16SymmOperands = {}, 9733 // int -> FLOAT16 map 9734 .float16Operands = {}, 9735 // int -> BOOL8 map 9736 .bool8Operands = {}, 9737 // int -> QUANT8_SYMM_PER_CHANNEL map 9738 .quant8ChannelOperands = {}, 9739 // int -> QUANT16_ASYMM map 9740 .quant16AsymmOperands = {}, 9741 // int -> QUANT8_SYMM map 9742 .quant8SymmOperands = {}, 9743 } 9744 }, 9745 }, // End of an example 9746 }; 9747 return examples_dynamic_output_shape_nchw_none_relaxed; 9748 }; 9749 9750 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input() { 9751 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input = { 9752 // Begin of an example 9753 { 9754 .operands = { 9755 //Input(s) 9756 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9757 // int -> Dimensions map 9758 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9759 // int -> FLOAT32 map 9760 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 9761 // int -> INT32 map 9762 .int32Operands = {}, 9763 // int -> QUANT8_ASYMM map 9764 .quant8AsymmOperands = {}, 9765 // int -> QUANT16_SYMM map 9766 .quant16SymmOperands = {}, 9767 // int -> FLOAT16 map 9768 .float16Operands = {}, 9769 // int -> BOOL8 map 9770 .bool8Operands = {}, 9771 // int -> QUANT8_SYMM_PER_CHANNEL map 9772 .quant8ChannelOperands = {}, 9773 // int -> QUANT16_ASYMM map 9774 .quant16AsymmOperands = {}, 9775 // int -> QUANT8_SYMM map 9776 .quant8SymmOperands = {}, 9777 }, 9778 //Output(s) 9779 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9780 // int -> Dimensions map 9781 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9782 // int -> FLOAT32 map 9783 .float32Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 9784 // int -> INT32 map 9785 .int32Operands = {}, 9786 // int -> QUANT8_ASYMM map 9787 .quant8AsymmOperands = {}, 9788 // int -> QUANT16_SYMM map 9789 .quant16SymmOperands = {}, 9790 // int -> FLOAT16 map 9791 .float16Operands = {}, 9792 // int -> BOOL8 map 9793 .bool8Operands = {}, 9794 // int -> QUANT8_SYMM_PER_CHANNEL map 9795 .quant8ChannelOperands = {}, 9796 // int -> QUANT16_ASYMM map 9797 .quant16AsymmOperands = {}, 9798 // int -> QUANT8_SYMM map 9799 .quant8SymmOperands = {}, 9800 } 9801 }, 9802 }, // End of an example 9803 }; 9804 return examples_dynamic_output_shape_nchw_none_relaxed_weight_as_input; 9805 }; 9806 9807 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8() { 9808 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8 = { 9809 // Begin of an example 9810 { 9811 .operands = { 9812 //Input(s) 9813 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9814 // int -> Dimensions map 9815 .operandDimensions = {{0, {1, 1, 2, 2}}}, 9816 // int -> FLOAT32 map 9817 .float32Operands = {}, 9818 // int -> INT32 map 9819 .int32Operands = {}, 9820 // int -> QUANT8_ASYMM map 9821 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 9822 // int -> QUANT16_SYMM map 9823 .quant16SymmOperands = {}, 9824 // int -> FLOAT16 map 9825 .float16Operands = {}, 9826 // int -> BOOL8 map 9827 .bool8Operands = {}, 9828 // int -> QUANT8_SYMM_PER_CHANNEL map 9829 .quant8ChannelOperands = {}, 9830 // int -> QUANT16_ASYMM map 9831 .quant16AsymmOperands = {}, 9832 // int -> QUANT8_SYMM map 9833 .quant8SymmOperands = {}, 9834 }, 9835 //Output(s) 9836 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9837 // int -> Dimensions map 9838 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9839 // int -> FLOAT32 map 9840 .float32Operands = {}, 9841 // int -> INT32 map 9842 .int32Operands = {}, 9843 // int -> QUANT8_ASYMM map 9844 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 9845 // int -> QUANT16_SYMM map 9846 .quant16SymmOperands = {}, 9847 // int -> FLOAT16 map 9848 .float16Operands = {}, 9849 // int -> BOOL8 map 9850 .bool8Operands = {}, 9851 // int -> QUANT8_SYMM_PER_CHANNEL map 9852 .quant8ChannelOperands = {}, 9853 // int -> QUANT16_ASYMM map 9854 .quant16AsymmOperands = {}, 9855 // int -> QUANT8_SYMM map 9856 .quant8SymmOperands = {}, 9857 } 9858 }, 9859 }, // End of an example 9860 }; 9861 return examples_dynamic_output_shape_nchw_none_quant8; 9862 }; 9863 9864 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input() { 9865 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_weight_as_input = { 9866 // Begin of an example 9867 { 9868 .operands = { 9869 //Input(s) 9870 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9871 // int -> Dimensions map 9872 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9873 // int -> FLOAT32 map 9874 .float32Operands = {}, 9875 // int -> INT32 map 9876 .int32Operands = {{2, {-6, -8}}}, 9877 // int -> QUANT8_ASYMM map 9878 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 9879 // int -> QUANT16_SYMM map 9880 .quant16SymmOperands = {}, 9881 // int -> FLOAT16 map 9882 .float16Operands = {}, 9883 // int -> BOOL8 map 9884 .bool8Operands = {}, 9885 // int -> QUANT8_SYMM_PER_CHANNEL map 9886 .quant8ChannelOperands = {}, 9887 // int -> QUANT16_ASYMM map 9888 .quant16AsymmOperands = {}, 9889 // int -> QUANT8_SYMM map 9890 .quant8SymmOperands = {}, 9891 }, 9892 //Output(s) 9893 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9894 // int -> Dimensions map 9895 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9896 // int -> FLOAT32 map 9897 .float32Operands = {}, 9898 // int -> INT32 map 9899 .int32Operands = {}, 9900 // int -> QUANT8_ASYMM map 9901 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 9902 // int -> QUANT16_SYMM map 9903 .quant16SymmOperands = {}, 9904 // int -> FLOAT16 map 9905 .float16Operands = {}, 9906 // int -> BOOL8 map 9907 .bool8Operands = {}, 9908 // int -> QUANT8_SYMM_PER_CHANNEL map 9909 .quant8ChannelOperands = {}, 9910 // int -> QUANT16_ASYMM map 9911 .quant16AsymmOperands = {}, 9912 // int -> QUANT8_SYMM map 9913 .quant8SymmOperands = {}, 9914 } 9915 }, 9916 }, // End of an example 9917 }; 9918 return examples_dynamic_output_shape_nchw_none_quant8_weight_as_input; 9919 }; 9920 9921 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_2() { 9922 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_2 = { 9923 // Begin of an example 9924 { 9925 .operands = { 9926 //Input(s) 9927 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9928 // int -> Dimensions map 9929 .operandDimensions = {{0, {1, 1, 2, 2}}}, 9930 // int -> FLOAT32 map 9931 .float32Operands = {}, 9932 // int -> INT32 map 9933 .int32Operands = {}, 9934 // int -> QUANT8_ASYMM map 9935 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 9936 // int -> QUANT16_SYMM map 9937 .quant16SymmOperands = {}, 9938 // int -> FLOAT16 map 9939 .float16Operands = {}, 9940 // int -> BOOL8 map 9941 .bool8Operands = {}, 9942 // int -> QUANT8_SYMM_PER_CHANNEL map 9943 .quant8ChannelOperands = {}, 9944 // int -> QUANT16_ASYMM map 9945 .quant16AsymmOperands = {}, 9946 // int -> QUANT8_SYMM map 9947 .quant8SymmOperands = {}, 9948 }, 9949 //Output(s) 9950 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9951 // int -> Dimensions map 9952 .operandDimensions = {{0, {1, 2, 5, 5}}}, 9953 // int -> FLOAT32 map 9954 .float32Operands = {}, 9955 // int -> INT32 map 9956 .int32Operands = {}, 9957 // int -> QUANT8_ASYMM map 9958 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 9959 // int -> QUANT16_SYMM map 9960 .quant16SymmOperands = {}, 9961 // int -> FLOAT16 map 9962 .float16Operands = {}, 9963 // int -> BOOL8 map 9964 .bool8Operands = {}, 9965 // int -> QUANT8_SYMM_PER_CHANNEL map 9966 .quant8ChannelOperands = {}, 9967 // int -> QUANT16_ASYMM map 9968 .quant16AsymmOperands = {}, 9969 // int -> QUANT8_SYMM map 9970 .quant8SymmOperands = {}, 9971 } 9972 }, 9973 }, // End of an example 9974 }; 9975 return examples_dynamic_output_shape_nchw_none_quant8_2; 9976 }; 9977 9978 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2() { 9979 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2 = { 9980 // Begin of an example 9981 { 9982 .operands = { 9983 //Input(s) 9984 { // See tools/test_generator/include/TestHarness.h:MixedTyped 9985 // int -> Dimensions map 9986 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 9987 // int -> FLOAT32 map 9988 .float32Operands = {}, 9989 // int -> INT32 map 9990 .int32Operands = {{2, {-6, -8}}}, 9991 // int -> QUANT8_ASYMM map 9992 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 9993 // int -> QUANT16_SYMM map 9994 .quant16SymmOperands = {}, 9995 // int -> FLOAT16 map 9996 .float16Operands = {}, 9997 // int -> BOOL8 map 9998 .bool8Operands = {}, 9999 // int -> QUANT8_SYMM_PER_CHANNEL map 10000 .quant8ChannelOperands = {}, 10001 // int -> QUANT16_ASYMM map 10002 .quant16AsymmOperands = {}, 10003 // int -> QUANT8_SYMM map 10004 .quant8SymmOperands = {}, 10005 }, 10006 //Output(s) 10007 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10008 // int -> Dimensions map 10009 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10010 // int -> FLOAT32 map 10011 .float32Operands = {}, 10012 // int -> INT32 map 10013 .int32Operands = {}, 10014 // int -> QUANT8_ASYMM map 10015 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10016 // int -> QUANT16_SYMM map 10017 .quant16SymmOperands = {}, 10018 // int -> FLOAT16 map 10019 .float16Operands = {}, 10020 // int -> BOOL8 map 10021 .bool8Operands = {}, 10022 // int -> QUANT8_SYMM_PER_CHANNEL map 10023 .quant8ChannelOperands = {}, 10024 // int -> QUANT16_ASYMM map 10025 .quant16AsymmOperands = {}, 10026 // int -> QUANT8_SYMM map 10027 .quant8SymmOperands = {}, 10028 } 10029 }, 10030 }, // End of an example 10031 }; 10032 return examples_dynamic_output_shape_nchw_none_quant8_weight_as_input_2; 10033 }; 10034 10035 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8() { 10036 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8 = { 10037 // Begin of an example 10038 { 10039 .operands = { 10040 //Input(s) 10041 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10042 // int -> Dimensions map 10043 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10044 // int -> FLOAT32 map 10045 .float32Operands = {}, 10046 // int -> INT32 map 10047 .int32Operands = {}, 10048 // int -> QUANT8_ASYMM map 10049 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10050 // int -> QUANT16_SYMM map 10051 .quant16SymmOperands = {}, 10052 // int -> FLOAT16 map 10053 .float16Operands = {}, 10054 // int -> BOOL8 map 10055 .bool8Operands = {}, 10056 // int -> QUANT8_SYMM_PER_CHANNEL map 10057 .quant8ChannelOperands = {}, 10058 // int -> QUANT16_ASYMM map 10059 .quant16AsymmOperands = {}, 10060 // int -> QUANT8_SYMM map 10061 .quant8SymmOperands = {}, 10062 }, 10063 //Output(s) 10064 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10065 // int -> Dimensions map 10066 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10067 // int -> FLOAT32 map 10068 .float32Operands = {}, 10069 // int -> INT32 map 10070 .int32Operands = {}, 10071 // int -> QUANT8_ASYMM map 10072 .quant8AsymmOperands = {{0, {79, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 10073 // int -> QUANT16_SYMM map 10074 .quant16SymmOperands = {}, 10075 // int -> FLOAT16 map 10076 .float16Operands = {}, 10077 // int -> BOOL8 map 10078 .bool8Operands = {}, 10079 // int -> QUANT8_SYMM_PER_CHANNEL map 10080 .quant8ChannelOperands = {}, 10081 // int -> QUANT16_ASYMM map 10082 .quant16AsymmOperands = {}, 10083 // int -> QUANT8_SYMM map 10084 .quant8SymmOperands = {}, 10085 } 10086 }, 10087 }, // End of an example 10088 }; 10089 return examples_dynamic_output_shape_nchw_none_channelQuant8; 10090 }; 10091 10092 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input() { 10093 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input = { 10094 // Begin of an example 10095 { 10096 .operands = { 10097 //Input(s) 10098 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10099 // int -> Dimensions map 10100 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10101 // int -> FLOAT32 map 10102 .float32Operands = {}, 10103 // int -> INT32 map 10104 .int32Operands = {{2, {-24, -16}}}, 10105 // int -> QUANT8_ASYMM map 10106 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10107 // int -> QUANT16_SYMM map 10108 .quant16SymmOperands = {}, 10109 // int -> FLOAT16 map 10110 .float16Operands = {}, 10111 // int -> BOOL8 map 10112 .bool8Operands = {}, 10113 // int -> QUANT8_SYMM_PER_CHANNEL map 10114 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 10115 // int -> QUANT16_ASYMM map 10116 .quant16AsymmOperands = {}, 10117 // int -> QUANT8_SYMM map 10118 .quant8SymmOperands = {}, 10119 }, 10120 //Output(s) 10121 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10122 // int -> Dimensions map 10123 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10124 // int -> FLOAT32 map 10125 .float32Operands = {}, 10126 // int -> INT32 map 10127 .int32Operands = {}, 10128 // int -> QUANT8_ASYMM map 10129 .quant8AsymmOperands = {{0, {79, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 10130 // int -> QUANT16_SYMM map 10131 .quant16SymmOperands = {}, 10132 // int -> FLOAT16 map 10133 .float16Operands = {}, 10134 // int -> BOOL8 map 10135 .bool8Operands = {}, 10136 // int -> QUANT8_SYMM_PER_CHANNEL map 10137 .quant8ChannelOperands = {}, 10138 // int -> QUANT16_ASYMM map 10139 .quant16AsymmOperands = {}, 10140 // int -> QUANT8_SYMM map 10141 .quant8SymmOperands = {}, 10142 } 10143 }, 10144 }, // End of an example 10145 }; 10146 return examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input; 10147 }; 10148 10149 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_2() { 10150 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_2 = { 10151 // Begin of an example 10152 { 10153 .operands = { 10154 //Input(s) 10155 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10156 // int -> Dimensions map 10157 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10158 // int -> FLOAT32 map 10159 .float32Operands = {}, 10160 // int -> INT32 map 10161 .int32Operands = {}, 10162 // int -> QUANT8_ASYMM map 10163 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10164 // int -> QUANT16_SYMM map 10165 .quant16SymmOperands = {}, 10166 // int -> FLOAT16 map 10167 .float16Operands = {}, 10168 // int -> BOOL8 map 10169 .bool8Operands = {}, 10170 // int -> QUANT8_SYMM_PER_CHANNEL map 10171 .quant8ChannelOperands = {}, 10172 // int -> QUANT16_ASYMM map 10173 .quant16AsymmOperands = {}, 10174 // int -> QUANT8_SYMM map 10175 .quant8SymmOperands = {}, 10176 }, 10177 //Output(s) 10178 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10179 // int -> Dimensions map 10180 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10181 // int -> FLOAT32 map 10182 .float32Operands = {}, 10183 // int -> INT32 map 10184 .int32Operands = {}, 10185 // int -> QUANT8_ASYMM map 10186 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10187 // int -> QUANT16_SYMM map 10188 .quant16SymmOperands = {}, 10189 // int -> FLOAT16 map 10190 .float16Operands = {}, 10191 // int -> BOOL8 map 10192 .bool8Operands = {}, 10193 // int -> QUANT8_SYMM_PER_CHANNEL map 10194 .quant8ChannelOperands = {}, 10195 // int -> QUANT16_ASYMM map 10196 .quant16AsymmOperands = {}, 10197 // int -> QUANT8_SYMM map 10198 .quant8SymmOperands = {}, 10199 } 10200 }, 10201 }, // End of an example 10202 }; 10203 return examples_dynamic_output_shape_nchw_none_channelQuant8_2; 10204 }; 10205 10206 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2() { 10207 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2 = { 10208 // Begin of an example 10209 { 10210 .operands = { 10211 //Input(s) 10212 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10213 // int -> Dimensions map 10214 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10215 // int -> FLOAT32 map 10216 .float32Operands = {}, 10217 // int -> INT32 map 10218 .int32Operands = {{2, {-24, -16}}}, 10219 // int -> QUANT8_ASYMM map 10220 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10221 // int -> QUANT16_SYMM map 10222 .quant16SymmOperands = {}, 10223 // int -> FLOAT16 map 10224 .float16Operands = {}, 10225 // int -> BOOL8 map 10226 .bool8Operands = {}, 10227 // int -> QUANT8_SYMM_PER_CHANNEL map 10228 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 10229 // int -> QUANT16_ASYMM map 10230 .quant16AsymmOperands = {}, 10231 // int -> QUANT8_SYMM map 10232 .quant8SymmOperands = {}, 10233 }, 10234 //Output(s) 10235 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10236 // int -> Dimensions map 10237 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10238 // int -> FLOAT32 map 10239 .float32Operands = {}, 10240 // int -> INT32 map 10241 .int32Operands = {}, 10242 // int -> QUANT8_ASYMM map 10243 .quant8AsymmOperands = {{0, {75, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10244 // int -> QUANT16_SYMM map 10245 .quant16SymmOperands = {}, 10246 // int -> FLOAT16 map 10247 .float16Operands = {}, 10248 // int -> BOOL8 map 10249 .bool8Operands = {}, 10250 // int -> QUANT8_SYMM_PER_CHANNEL map 10251 .quant8ChannelOperands = {}, 10252 // int -> QUANT16_ASYMM map 10253 .quant16AsymmOperands = {}, 10254 // int -> QUANT8_SYMM map 10255 .quant8SymmOperands = {}, 10256 } 10257 }, 10258 }, // End of an example 10259 }; 10260 return examples_dynamic_output_shape_nchw_none_channelQuant8_weight_as_input_2; 10261 }; 10262 10263 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_float16() { 10264 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_float16 = { 10265 // Begin of an example 10266 { 10267 .operands = { 10268 //Input(s) 10269 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10270 // int -> Dimensions map 10271 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10272 // int -> FLOAT32 map 10273 .float32Operands = {}, 10274 // int -> INT32 map 10275 .int32Operands = {}, 10276 // int -> QUANT8_ASYMM map 10277 .quant8AsymmOperands = {}, 10278 // int -> QUANT16_SYMM map 10279 .quant16SymmOperands = {}, 10280 // int -> FLOAT16 map 10281 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 10282 // int -> BOOL8 map 10283 .bool8Operands = {}, 10284 // int -> QUANT8_SYMM_PER_CHANNEL map 10285 .quant8ChannelOperands = {}, 10286 // int -> QUANT16_ASYMM map 10287 .quant16AsymmOperands = {}, 10288 // int -> QUANT8_SYMM map 10289 .quant8SymmOperands = {}, 10290 }, 10291 //Output(s) 10292 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10293 // int -> Dimensions map 10294 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10295 // int -> FLOAT32 map 10296 .float32Operands = {}, 10297 // int -> INT32 map 10298 .int32Operands = {}, 10299 // int -> QUANT8_ASYMM map 10300 .quant8AsymmOperands = {}, 10301 // int -> QUANT16_SYMM map 10302 .quant16SymmOperands = {}, 10303 // int -> FLOAT16 map 10304 .float16Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10305 // int -> BOOL8 map 10306 .bool8Operands = {}, 10307 // int -> QUANT8_SYMM_PER_CHANNEL map 10308 .quant8ChannelOperands = {}, 10309 // int -> QUANT16_ASYMM map 10310 .quant16AsymmOperands = {}, 10311 // int -> QUANT8_SYMM map 10312 .quant8SymmOperands = {}, 10313 } 10314 }, 10315 }, // End of an example 10316 }; 10317 return examples_dynamic_output_shape_nchw_none_float16; 10318 }; 10319 10320 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_none_float16_weight_as_input() { 10321 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_none_float16_weight_as_input = { 10322 // Begin of an example 10323 { 10324 .operands = { 10325 //Input(s) 10326 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10327 // int -> Dimensions map 10328 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10329 // int -> FLOAT32 map 10330 .float32Operands = {}, 10331 // int -> INT32 map 10332 .int32Operands = {}, 10333 // int -> QUANT8_ASYMM map 10334 .quant8AsymmOperands = {}, 10335 // int -> QUANT16_SYMM map 10336 .quant16SymmOperands = {}, 10337 // int -> FLOAT16 map 10338 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 10339 // int -> BOOL8 map 10340 .bool8Operands = {}, 10341 // int -> QUANT8_SYMM_PER_CHANNEL map 10342 .quant8ChannelOperands = {}, 10343 // int -> QUANT16_ASYMM map 10344 .quant16AsymmOperands = {}, 10345 // int -> QUANT8_SYMM map 10346 .quant8SymmOperands = {}, 10347 }, 10348 //Output(s) 10349 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10350 // int -> Dimensions map 10351 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10352 // int -> FLOAT32 map 10353 .float32Operands = {}, 10354 // int -> INT32 map 10355 .int32Operands = {}, 10356 // int -> QUANT8_ASYMM map 10357 .quant8AsymmOperands = {}, 10358 // int -> QUANT16_SYMM map 10359 .quant16SymmOperands = {}, 10360 // int -> FLOAT16 map 10361 .float16Operands = {{0, {-0.5f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10362 // int -> BOOL8 map 10363 .bool8Operands = {}, 10364 // int -> QUANT8_SYMM_PER_CHANNEL map 10365 .quant8ChannelOperands = {}, 10366 // int -> QUANT16_ASYMM map 10367 .quant16AsymmOperands = {}, 10368 // int -> QUANT8_SYMM map 10369 .quant8SymmOperands = {}, 10370 } 10371 }, 10372 }, // End of an example 10373 }; 10374 return examples_dynamic_output_shape_nchw_none_float16_weight_as_input; 10375 }; 10376 10377 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu() { 10378 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu = { 10379 // Begin of an example 10380 { 10381 .operands = { 10382 //Input(s) 10383 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10384 // int -> Dimensions map 10385 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10386 // int -> FLOAT32 map 10387 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 10388 // int -> INT32 map 10389 .int32Operands = {}, 10390 // int -> QUANT8_ASYMM map 10391 .quant8AsymmOperands = {}, 10392 // int -> QUANT16_SYMM map 10393 .quant16SymmOperands = {}, 10394 // int -> FLOAT16 map 10395 .float16Operands = {}, 10396 // int -> BOOL8 map 10397 .bool8Operands = {}, 10398 // int -> QUANT8_SYMM_PER_CHANNEL map 10399 .quant8ChannelOperands = {}, 10400 // int -> QUANT16_ASYMM map 10401 .quant16AsymmOperands = {}, 10402 // int -> QUANT8_SYMM map 10403 .quant8SymmOperands = {}, 10404 }, 10405 //Output(s) 10406 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10407 // int -> Dimensions map 10408 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10409 // int -> FLOAT32 map 10410 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10411 // int -> INT32 map 10412 .int32Operands = {}, 10413 // int -> QUANT8_ASYMM map 10414 .quant8AsymmOperands = {}, 10415 // int -> QUANT16_SYMM map 10416 .quant16SymmOperands = {}, 10417 // int -> FLOAT16 map 10418 .float16Operands = {}, 10419 // int -> BOOL8 map 10420 .bool8Operands = {}, 10421 // int -> QUANT8_SYMM_PER_CHANNEL map 10422 .quant8ChannelOperands = {}, 10423 // int -> QUANT16_ASYMM map 10424 .quant16AsymmOperands = {}, 10425 // int -> QUANT8_SYMM map 10426 .quant8SymmOperands = {}, 10427 } 10428 }, 10429 }, // End of an example 10430 }; 10431 return examples_dynamic_output_shape_nchw_relu; 10432 }; 10433 10434 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_weight_as_input() { 10435 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_weight_as_input = { 10436 // Begin of an example 10437 { 10438 .operands = { 10439 //Input(s) 10440 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10441 // int -> Dimensions map 10442 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10443 // int -> FLOAT32 map 10444 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 10445 // int -> INT32 map 10446 .int32Operands = {}, 10447 // int -> QUANT8_ASYMM map 10448 .quant8AsymmOperands = {}, 10449 // int -> QUANT16_SYMM map 10450 .quant16SymmOperands = {}, 10451 // int -> FLOAT16 map 10452 .float16Operands = {}, 10453 // int -> BOOL8 map 10454 .bool8Operands = {}, 10455 // int -> QUANT8_SYMM_PER_CHANNEL map 10456 .quant8ChannelOperands = {}, 10457 // int -> QUANT16_ASYMM map 10458 .quant16AsymmOperands = {}, 10459 // int -> QUANT8_SYMM map 10460 .quant8SymmOperands = {}, 10461 }, 10462 //Output(s) 10463 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10464 // int -> Dimensions map 10465 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10466 // int -> FLOAT32 map 10467 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10468 // int -> INT32 map 10469 .int32Operands = {}, 10470 // int -> QUANT8_ASYMM map 10471 .quant8AsymmOperands = {}, 10472 // int -> QUANT16_SYMM map 10473 .quant16SymmOperands = {}, 10474 // int -> FLOAT16 map 10475 .float16Operands = {}, 10476 // int -> BOOL8 map 10477 .bool8Operands = {}, 10478 // int -> QUANT8_SYMM_PER_CHANNEL map 10479 .quant8ChannelOperands = {}, 10480 // int -> QUANT16_ASYMM map 10481 .quant16AsymmOperands = {}, 10482 // int -> QUANT8_SYMM map 10483 .quant8SymmOperands = {}, 10484 } 10485 }, 10486 }, // End of an example 10487 }; 10488 return examples_dynamic_output_shape_nchw_relu_weight_as_input; 10489 }; 10490 10491 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_relaxed() { 10492 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_relaxed = { 10493 // Begin of an example 10494 { 10495 .operands = { 10496 //Input(s) 10497 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10498 // int -> Dimensions map 10499 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10500 // int -> FLOAT32 map 10501 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 10502 // int -> INT32 map 10503 .int32Operands = {}, 10504 // int -> QUANT8_ASYMM map 10505 .quant8AsymmOperands = {}, 10506 // int -> QUANT16_SYMM map 10507 .quant16SymmOperands = {}, 10508 // int -> FLOAT16 map 10509 .float16Operands = {}, 10510 // int -> BOOL8 map 10511 .bool8Operands = {}, 10512 // int -> QUANT8_SYMM_PER_CHANNEL map 10513 .quant8ChannelOperands = {}, 10514 // int -> QUANT16_ASYMM map 10515 .quant16AsymmOperands = {}, 10516 // int -> QUANT8_SYMM map 10517 .quant8SymmOperands = {}, 10518 }, 10519 //Output(s) 10520 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10521 // int -> Dimensions map 10522 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10523 // int -> FLOAT32 map 10524 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10525 // int -> INT32 map 10526 .int32Operands = {}, 10527 // int -> QUANT8_ASYMM map 10528 .quant8AsymmOperands = {}, 10529 // int -> QUANT16_SYMM map 10530 .quant16SymmOperands = {}, 10531 // int -> FLOAT16 map 10532 .float16Operands = {}, 10533 // int -> BOOL8 map 10534 .bool8Operands = {}, 10535 // int -> QUANT8_SYMM_PER_CHANNEL map 10536 .quant8ChannelOperands = {}, 10537 // int -> QUANT16_ASYMM map 10538 .quant16AsymmOperands = {}, 10539 // int -> QUANT8_SYMM map 10540 .quant8SymmOperands = {}, 10541 } 10542 }, 10543 }, // End of an example 10544 }; 10545 return examples_dynamic_output_shape_nchw_relu_relaxed; 10546 }; 10547 10548 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input() { 10549 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input = { 10550 // Begin of an example 10551 { 10552 .operands = { 10553 //Input(s) 10554 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10555 // int -> Dimensions map 10556 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10557 // int -> FLOAT32 map 10558 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 10559 // int -> INT32 map 10560 .int32Operands = {}, 10561 // int -> QUANT8_ASYMM map 10562 .quant8AsymmOperands = {}, 10563 // int -> QUANT16_SYMM map 10564 .quant16SymmOperands = {}, 10565 // int -> FLOAT16 map 10566 .float16Operands = {}, 10567 // int -> BOOL8 map 10568 .bool8Operands = {}, 10569 // int -> QUANT8_SYMM_PER_CHANNEL map 10570 .quant8ChannelOperands = {}, 10571 // int -> QUANT16_ASYMM map 10572 .quant16AsymmOperands = {}, 10573 // int -> QUANT8_SYMM map 10574 .quant8SymmOperands = {}, 10575 }, 10576 //Output(s) 10577 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10578 // int -> Dimensions map 10579 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10580 // int -> FLOAT32 map 10581 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 10582 // int -> INT32 map 10583 .int32Operands = {}, 10584 // int -> QUANT8_ASYMM map 10585 .quant8AsymmOperands = {}, 10586 // int -> QUANT16_SYMM map 10587 .quant16SymmOperands = {}, 10588 // int -> FLOAT16 map 10589 .float16Operands = {}, 10590 // int -> BOOL8 map 10591 .bool8Operands = {}, 10592 // int -> QUANT8_SYMM_PER_CHANNEL map 10593 .quant8ChannelOperands = {}, 10594 // int -> QUANT16_ASYMM map 10595 .quant16AsymmOperands = {}, 10596 // int -> QUANT8_SYMM map 10597 .quant8SymmOperands = {}, 10598 } 10599 }, 10600 }, // End of an example 10601 }; 10602 return examples_dynamic_output_shape_nchw_relu_relaxed_weight_as_input; 10603 }; 10604 10605 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8() { 10606 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8 = { 10607 // Begin of an example 10608 { 10609 .operands = { 10610 //Input(s) 10611 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10612 // int -> Dimensions map 10613 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10614 // int -> FLOAT32 map 10615 .float32Operands = {}, 10616 // int -> INT32 map 10617 .int32Operands = {}, 10618 // int -> QUANT8_ASYMM map 10619 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 10620 // int -> QUANT16_SYMM map 10621 .quant16SymmOperands = {}, 10622 // int -> FLOAT16 map 10623 .float16Operands = {}, 10624 // int -> BOOL8 map 10625 .bool8Operands = {}, 10626 // int -> QUANT8_SYMM_PER_CHANNEL map 10627 .quant8ChannelOperands = {}, 10628 // int -> QUANT16_ASYMM map 10629 .quant16AsymmOperands = {}, 10630 // int -> QUANT8_SYMM map 10631 .quant8SymmOperands = {}, 10632 }, 10633 //Output(s) 10634 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10635 // int -> Dimensions map 10636 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10637 // int -> FLOAT32 map 10638 .float32Operands = {}, 10639 // int -> INT32 map 10640 .int32Operands = {}, 10641 // int -> QUANT8_ASYMM map 10642 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 10643 // int -> QUANT16_SYMM map 10644 .quant16SymmOperands = {}, 10645 // int -> FLOAT16 map 10646 .float16Operands = {}, 10647 // int -> BOOL8 map 10648 .bool8Operands = {}, 10649 // int -> QUANT8_SYMM_PER_CHANNEL map 10650 .quant8ChannelOperands = {}, 10651 // int -> QUANT16_ASYMM map 10652 .quant16AsymmOperands = {}, 10653 // int -> QUANT8_SYMM map 10654 .quant8SymmOperands = {}, 10655 } 10656 }, 10657 }, // End of an example 10658 }; 10659 return examples_dynamic_output_shape_nchw_relu_quant8; 10660 }; 10661 10662 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input() { 10663 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input = { 10664 // Begin of an example 10665 { 10666 .operands = { 10667 //Input(s) 10668 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10669 // int -> Dimensions map 10670 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10671 // int -> FLOAT32 map 10672 .float32Operands = {}, 10673 // int -> INT32 map 10674 .int32Operands = {{2, {-6, -8}}}, 10675 // int -> QUANT8_ASYMM map 10676 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 10677 // int -> QUANT16_SYMM map 10678 .quant16SymmOperands = {}, 10679 // int -> FLOAT16 map 10680 .float16Operands = {}, 10681 // int -> BOOL8 map 10682 .bool8Operands = {}, 10683 // int -> QUANT8_SYMM_PER_CHANNEL map 10684 .quant8ChannelOperands = {}, 10685 // int -> QUANT16_ASYMM map 10686 .quant16AsymmOperands = {}, 10687 // int -> QUANT8_SYMM map 10688 .quant8SymmOperands = {}, 10689 }, 10690 //Output(s) 10691 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10692 // int -> Dimensions map 10693 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10694 // int -> FLOAT32 map 10695 .float32Operands = {}, 10696 // int -> INT32 map 10697 .int32Operands = {}, 10698 // int -> QUANT8_ASYMM map 10699 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 17, 11, 15, 47, 33, 41, 29, 45, 121, 81, 105, 39, 51, 119, 69, 85, 75, 87, 203, 117, 133, 0, 4, 16, 12, 20, 12, 16, 52, 36, 44, 36, 52, 140, 92, 116, 44, 56, 132, 76, 92, 80, 92, 216, 124, 140}}}, 10700 // int -> QUANT16_SYMM map 10701 .quant16SymmOperands = {}, 10702 // int -> FLOAT16 map 10703 .float16Operands = {}, 10704 // int -> BOOL8 map 10705 .bool8Operands = {}, 10706 // int -> QUANT8_SYMM_PER_CHANNEL map 10707 .quant8ChannelOperands = {}, 10708 // int -> QUANT16_ASYMM map 10709 .quant16AsymmOperands = {}, 10710 // int -> QUANT8_SYMM map 10711 .quant8SymmOperands = {}, 10712 } 10713 }, 10714 }, // End of an example 10715 }; 10716 return examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input; 10717 }; 10718 10719 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_2() { 10720 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_2 = { 10721 // Begin of an example 10722 { 10723 .operands = { 10724 //Input(s) 10725 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10726 // int -> Dimensions map 10727 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10728 // int -> FLOAT32 map 10729 .float32Operands = {}, 10730 // int -> INT32 map 10731 .int32Operands = {}, 10732 // int -> QUANT8_ASYMM map 10733 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 10734 // int -> QUANT16_SYMM map 10735 .quant16SymmOperands = {}, 10736 // int -> FLOAT16 map 10737 .float16Operands = {}, 10738 // int -> BOOL8 map 10739 .bool8Operands = {}, 10740 // int -> QUANT8_SYMM_PER_CHANNEL map 10741 .quant8ChannelOperands = {}, 10742 // int -> QUANT16_ASYMM map 10743 .quant16AsymmOperands = {}, 10744 // int -> QUANT8_SYMM map 10745 .quant8SymmOperands = {}, 10746 }, 10747 //Output(s) 10748 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10749 // int -> Dimensions map 10750 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10751 // int -> FLOAT32 map 10752 .float32Operands = {}, 10753 // int -> INT32 map 10754 .int32Operands = {}, 10755 // int -> QUANT8_ASYMM map 10756 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10757 // int -> QUANT16_SYMM map 10758 .quant16SymmOperands = {}, 10759 // int -> FLOAT16 map 10760 .float16Operands = {}, 10761 // int -> BOOL8 map 10762 .bool8Operands = {}, 10763 // int -> QUANT8_SYMM_PER_CHANNEL map 10764 .quant8ChannelOperands = {}, 10765 // int -> QUANT16_ASYMM map 10766 .quant16AsymmOperands = {}, 10767 // int -> QUANT8_SYMM map 10768 .quant8SymmOperands = {}, 10769 } 10770 }, 10771 }, // End of an example 10772 }; 10773 return examples_dynamic_output_shape_nchw_relu_quant8_2; 10774 }; 10775 10776 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2() { 10777 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2 = { 10778 // Begin of an example 10779 { 10780 .operands = { 10781 //Input(s) 10782 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10783 // int -> Dimensions map 10784 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10785 // int -> FLOAT32 map 10786 .float32Operands = {}, 10787 // int -> INT32 map 10788 .int32Operands = {{2, {-6, -8}}}, 10789 // int -> QUANT8_ASYMM map 10790 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 10791 // int -> QUANT16_SYMM map 10792 .quant16SymmOperands = {}, 10793 // int -> FLOAT16 map 10794 .float16Operands = {}, 10795 // int -> BOOL8 map 10796 .bool8Operands = {}, 10797 // int -> QUANT8_SYMM_PER_CHANNEL map 10798 .quant8ChannelOperands = {}, 10799 // int -> QUANT16_ASYMM map 10800 .quant16AsymmOperands = {}, 10801 // int -> QUANT8_SYMM map 10802 .quant8SymmOperands = {}, 10803 }, 10804 //Output(s) 10805 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10806 // int -> Dimensions map 10807 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10808 // int -> FLOAT32 map 10809 .float32Operands = {}, 10810 // int -> INT32 map 10811 .int32Operands = {}, 10812 // int -> QUANT8_ASYMM map 10813 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10814 // int -> QUANT16_SYMM map 10815 .quant16SymmOperands = {}, 10816 // int -> FLOAT16 map 10817 .float16Operands = {}, 10818 // int -> BOOL8 map 10819 .bool8Operands = {}, 10820 // int -> QUANT8_SYMM_PER_CHANNEL map 10821 .quant8ChannelOperands = {}, 10822 // int -> QUANT16_ASYMM map 10823 .quant16AsymmOperands = {}, 10824 // int -> QUANT8_SYMM map 10825 .quant8SymmOperands = {}, 10826 } 10827 }, 10828 }, // End of an example 10829 }; 10830 return examples_dynamic_output_shape_nchw_relu_quant8_weight_as_input_2; 10831 }; 10832 10833 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8() { 10834 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8 = { 10835 // Begin of an example 10836 { 10837 .operands = { 10838 //Input(s) 10839 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10840 // int -> Dimensions map 10841 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10842 // int -> FLOAT32 map 10843 .float32Operands = {}, 10844 // int -> INT32 map 10845 .int32Operands = {}, 10846 // int -> QUANT8_ASYMM map 10847 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10848 // int -> QUANT16_SYMM map 10849 .quant16SymmOperands = {}, 10850 // int -> FLOAT16 map 10851 .float16Operands = {}, 10852 // int -> BOOL8 map 10853 .bool8Operands = {}, 10854 // int -> QUANT8_SYMM_PER_CHANNEL map 10855 .quant8ChannelOperands = {}, 10856 // int -> QUANT16_ASYMM map 10857 .quant16AsymmOperands = {}, 10858 // int -> QUANT8_SYMM map 10859 .quant8SymmOperands = {}, 10860 }, 10861 //Output(s) 10862 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10863 // int -> Dimensions map 10864 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10865 // int -> FLOAT32 map 10866 .float32Operands = {}, 10867 // int -> INT32 map 10868 .int32Operands = {}, 10869 // int -> QUANT8_ASYMM map 10870 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 10871 // int -> QUANT16_SYMM map 10872 .quant16SymmOperands = {}, 10873 // int -> FLOAT16 map 10874 .float16Operands = {}, 10875 // int -> BOOL8 map 10876 .bool8Operands = {}, 10877 // int -> QUANT8_SYMM_PER_CHANNEL map 10878 .quant8ChannelOperands = {}, 10879 // int -> QUANT16_ASYMM map 10880 .quant16AsymmOperands = {}, 10881 // int -> QUANT8_SYMM map 10882 .quant8SymmOperands = {}, 10883 } 10884 }, 10885 }, // End of an example 10886 }; 10887 return examples_dynamic_output_shape_nchw_relu_channelQuant8; 10888 }; 10889 10890 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input() { 10891 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input = { 10892 // Begin of an example 10893 { 10894 .operands = { 10895 //Input(s) 10896 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10897 // int -> Dimensions map 10898 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 10899 // int -> FLOAT32 map 10900 .float32Operands = {}, 10901 // int -> INT32 map 10902 .int32Operands = {{2, {-24, -16}}}, 10903 // int -> QUANT8_ASYMM map 10904 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10905 // int -> QUANT16_SYMM map 10906 .quant16SymmOperands = {}, 10907 // int -> FLOAT16 map 10908 .float16Operands = {}, 10909 // int -> BOOL8 map 10910 .bool8Operands = {}, 10911 // int -> QUANT8_SYMM_PER_CHANNEL map 10912 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 10913 // int -> QUANT16_ASYMM map 10914 .quant16AsymmOperands = {}, 10915 // int -> QUANT8_SYMM map 10916 .quant8SymmOperands = {}, 10917 }, 10918 //Output(s) 10919 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10920 // int -> Dimensions map 10921 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10922 // int -> FLOAT32 map 10923 .float32Operands = {}, 10924 // int -> INT32 map 10925 .int32Operands = {}, 10926 // int -> QUANT8_ASYMM map 10927 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 97, 91, 95, 127, 113, 121, 109, 125, 201, 161, 185, 119, 131, 199, 149, 165, 155, 167, 255, 197, 213, 80, 84, 96, 92, 100, 92, 96, 132, 116, 124, 116, 132, 220, 172, 196, 124, 136, 212, 156, 172, 160, 172, 255, 204, 220}}}, 10928 // int -> QUANT16_SYMM map 10929 .quant16SymmOperands = {}, 10930 // int -> FLOAT16 map 10931 .float16Operands = {}, 10932 // int -> BOOL8 map 10933 .bool8Operands = {}, 10934 // int -> QUANT8_SYMM_PER_CHANNEL map 10935 .quant8ChannelOperands = {}, 10936 // int -> QUANT16_ASYMM map 10937 .quant16AsymmOperands = {}, 10938 // int -> QUANT8_SYMM map 10939 .quant8SymmOperands = {}, 10940 } 10941 }, 10942 }, // End of an example 10943 }; 10944 return examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input; 10945 }; 10946 10947 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_2() { 10948 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_2 = { 10949 // Begin of an example 10950 { 10951 .operands = { 10952 //Input(s) 10953 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10954 // int -> Dimensions map 10955 .operandDimensions = {{0, {1, 1, 2, 2}}}, 10956 // int -> FLOAT32 map 10957 .float32Operands = {}, 10958 // int -> INT32 map 10959 .int32Operands = {}, 10960 // int -> QUANT8_ASYMM map 10961 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 10962 // int -> QUANT16_SYMM map 10963 .quant16SymmOperands = {}, 10964 // int -> FLOAT16 map 10965 .float16Operands = {}, 10966 // int -> BOOL8 map 10967 .bool8Operands = {}, 10968 // int -> QUANT8_SYMM_PER_CHANNEL map 10969 .quant8ChannelOperands = {}, 10970 // int -> QUANT16_ASYMM map 10971 .quant16AsymmOperands = {}, 10972 // int -> QUANT8_SYMM map 10973 .quant8SymmOperands = {}, 10974 }, 10975 //Output(s) 10976 { // See tools/test_generator/include/TestHarness.h:MixedTyped 10977 // int -> Dimensions map 10978 .operandDimensions = {{0, {1, 2, 5, 5}}}, 10979 // int -> FLOAT32 map 10980 .float32Operands = {}, 10981 // int -> INT32 map 10982 .int32Operands = {}, 10983 // int -> QUANT8_ASYMM map 10984 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 10985 // int -> QUANT16_SYMM map 10986 .quant16SymmOperands = {}, 10987 // int -> FLOAT16 map 10988 .float16Operands = {}, 10989 // int -> BOOL8 map 10990 .bool8Operands = {}, 10991 // int -> QUANT8_SYMM_PER_CHANNEL map 10992 .quant8ChannelOperands = {}, 10993 // int -> QUANT16_ASYMM map 10994 .quant16AsymmOperands = {}, 10995 // int -> QUANT8_SYMM map 10996 .quant8SymmOperands = {}, 10997 } 10998 }, 10999 }, // End of an example 11000 }; 11001 return examples_dynamic_output_shape_nchw_relu_channelQuant8_2; 11002 }; 11003 11004 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2() { 11005 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2 = { 11006 // Begin of an example 11007 { 11008 .operands = { 11009 //Input(s) 11010 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11011 // int -> Dimensions map 11012 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11013 // int -> FLOAT32 map 11014 .float32Operands = {}, 11015 // int -> INT32 map 11016 .int32Operands = {{2, {-24, -16}}}, 11017 // int -> QUANT8_ASYMM map 11018 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 11019 // int -> QUANT16_SYMM map 11020 .quant16SymmOperands = {}, 11021 // int -> FLOAT16 map 11022 .float16Operands = {}, 11023 // int -> BOOL8 map 11024 .bool8Operands = {}, 11025 // int -> QUANT8_SYMM_PER_CHANNEL map 11026 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 11027 // int -> QUANT16_ASYMM map 11028 .quant16AsymmOperands = {}, 11029 // int -> QUANT8_SYMM map 11030 .quant8SymmOperands = {}, 11031 }, 11032 //Output(s) 11033 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11034 // int -> Dimensions map 11035 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11036 // int -> FLOAT32 map 11037 .float32Operands = {}, 11038 // int -> INT32 map 11039 .int32Operands = {}, 11040 // int -> QUANT8_ASYMM map 11041 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 165, 135, 155, 255, 245, 255, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 80, 100, 160, 140, 180, 140, 160, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}}, 11042 // int -> QUANT16_SYMM map 11043 .quant16SymmOperands = {}, 11044 // int -> FLOAT16 map 11045 .float16Operands = {}, 11046 // int -> BOOL8 map 11047 .bool8Operands = {}, 11048 // int -> QUANT8_SYMM_PER_CHANNEL map 11049 .quant8ChannelOperands = {}, 11050 // int -> QUANT16_ASYMM map 11051 .quant16AsymmOperands = {}, 11052 // int -> QUANT8_SYMM map 11053 .quant8SymmOperands = {}, 11054 } 11055 }, 11056 }, // End of an example 11057 }; 11058 return examples_dynamic_output_shape_nchw_relu_channelQuant8_weight_as_input_2; 11059 }; 11060 11061 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_float16() { 11062 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_float16 = { 11063 // Begin of an example 11064 { 11065 .operands = { 11066 //Input(s) 11067 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11068 // int -> Dimensions map 11069 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11070 // int -> FLOAT32 map 11071 .float32Operands = {}, 11072 // int -> INT32 map 11073 .int32Operands = {}, 11074 // int -> QUANT8_ASYMM map 11075 .quant8AsymmOperands = {}, 11076 // int -> QUANT16_SYMM map 11077 .quant16SymmOperands = {}, 11078 // int -> FLOAT16 map 11079 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 11080 // int -> BOOL8 map 11081 .bool8Operands = {}, 11082 // int -> QUANT8_SYMM_PER_CHANNEL map 11083 .quant8ChannelOperands = {}, 11084 // int -> QUANT16_ASYMM map 11085 .quant16AsymmOperands = {}, 11086 // int -> QUANT8_SYMM map 11087 .quant8SymmOperands = {}, 11088 }, 11089 //Output(s) 11090 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11091 // int -> Dimensions map 11092 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11093 // int -> FLOAT32 map 11094 .float32Operands = {}, 11095 // int -> INT32 map 11096 .int32Operands = {}, 11097 // int -> QUANT8_ASYMM map 11098 .quant8AsymmOperands = {}, 11099 // int -> QUANT16_SYMM map 11100 .quant16SymmOperands = {}, 11101 // int -> FLOAT16 map 11102 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 11103 // int -> BOOL8 map 11104 .bool8Operands = {}, 11105 // int -> QUANT8_SYMM_PER_CHANNEL map 11106 .quant8ChannelOperands = {}, 11107 // int -> QUANT16_ASYMM map 11108 .quant16AsymmOperands = {}, 11109 // int -> QUANT8_SYMM map 11110 .quant8SymmOperands = {}, 11111 } 11112 }, 11113 }, // End of an example 11114 }; 11115 return examples_dynamic_output_shape_nchw_relu_float16; 11116 }; 11117 11118 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu_float16_weight_as_input() { 11119 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu_float16_weight_as_input = { 11120 // Begin of an example 11121 { 11122 .operands = { 11123 //Input(s) 11124 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11125 // int -> Dimensions map 11126 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11127 // int -> FLOAT32 map 11128 .float32Operands = {}, 11129 // int -> INT32 map 11130 .int32Operands = {}, 11131 // int -> QUANT8_ASYMM map 11132 .quant8AsymmOperands = {}, 11133 // int -> QUANT16_SYMM map 11134 .quant16SymmOperands = {}, 11135 // int -> FLOAT16 map 11136 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 11137 // int -> BOOL8 map 11138 .bool8Operands = {}, 11139 // int -> QUANT8_SYMM_PER_CHANNEL map 11140 .quant8ChannelOperands = {}, 11141 // int -> QUANT16_ASYMM map 11142 .quant16AsymmOperands = {}, 11143 // int -> QUANT8_SYMM map 11144 .quant8SymmOperands = {}, 11145 }, 11146 //Output(s) 11147 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11148 // int -> Dimensions map 11149 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11150 // int -> FLOAT32 map 11151 .float32Operands = {}, 11152 // int -> INT32 map 11153 .int32Operands = {}, 11154 // int -> QUANT8_ASYMM map 11155 .quant8AsymmOperands = {}, 11156 // int -> QUANT16_SYMM map 11157 .quant16SymmOperands = {}, 11158 // int -> FLOAT16 map 11159 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 8.5f, 5.5f, 7.5f, 23.5f, 16.5f, 20.5f, 14.5f, 22.5f, 60.5f, 40.5f, 52.5f, 19.5f, 25.5f, 59.5f, 34.5f, 42.5f, 37.5f, 43.5f, 101.5f, 58.5f, 66.5f, 0.0f, 2.0f, 8.0f, 6.0f, 10.0f, 6.0f, 8.0f, 26.0f, 18.0f, 22.0f, 18.0f, 26.0f, 70.0f, 46.0f, 58.0f, 22.0f, 28.0f, 66.0f, 38.0f, 46.0f, 40.0f, 46.0f, 108.0f, 62.0f, 70.0f}}}, 11160 // int -> BOOL8 map 11161 .bool8Operands = {}, 11162 // int -> QUANT8_SYMM_PER_CHANNEL map 11163 .quant8ChannelOperands = {}, 11164 // int -> QUANT16_ASYMM map 11165 .quant16AsymmOperands = {}, 11166 // int -> QUANT8_SYMM map 11167 .quant8SymmOperands = {}, 11168 } 11169 }, 11170 }, // End of an example 11171 }; 11172 return examples_dynamic_output_shape_nchw_relu_float16_weight_as_input; 11173 }; 11174 11175 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1() { 11176 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1 = { 11177 // Begin of an example 11178 { 11179 .operands = { 11180 //Input(s) 11181 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11182 // int -> Dimensions map 11183 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11184 // int -> FLOAT32 map 11185 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 11186 // int -> INT32 map 11187 .int32Operands = {}, 11188 // int -> QUANT8_ASYMM map 11189 .quant8AsymmOperands = {}, 11190 // int -> QUANT16_SYMM map 11191 .quant16SymmOperands = {}, 11192 // int -> FLOAT16 map 11193 .float16Operands = {}, 11194 // int -> BOOL8 map 11195 .bool8Operands = {}, 11196 // int -> QUANT8_SYMM_PER_CHANNEL map 11197 .quant8ChannelOperands = {}, 11198 // int -> QUANT16_ASYMM map 11199 .quant16AsymmOperands = {}, 11200 // int -> QUANT8_SYMM map 11201 .quant8SymmOperands = {}, 11202 }, 11203 //Output(s) 11204 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11205 // int -> Dimensions map 11206 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11207 // int -> FLOAT32 map 11208 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11209 // int -> INT32 map 11210 .int32Operands = {}, 11211 // int -> QUANT8_ASYMM map 11212 .quant8AsymmOperands = {}, 11213 // int -> QUANT16_SYMM map 11214 .quant16SymmOperands = {}, 11215 // int -> FLOAT16 map 11216 .float16Operands = {}, 11217 // int -> BOOL8 map 11218 .bool8Operands = {}, 11219 // int -> QUANT8_SYMM_PER_CHANNEL map 11220 .quant8ChannelOperands = {}, 11221 // int -> QUANT16_ASYMM map 11222 .quant16AsymmOperands = {}, 11223 // int -> QUANT8_SYMM map 11224 .quant8SymmOperands = {}, 11225 } 11226 }, 11227 }, // End of an example 11228 }; 11229 return examples_dynamic_output_shape_nchw_relu1; 11230 }; 11231 11232 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_weight_as_input() { 11233 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_weight_as_input = { 11234 // Begin of an example 11235 { 11236 .operands = { 11237 //Input(s) 11238 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11239 // int -> Dimensions map 11240 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11241 // int -> FLOAT32 map 11242 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 11243 // int -> INT32 map 11244 .int32Operands = {}, 11245 // int -> QUANT8_ASYMM map 11246 .quant8AsymmOperands = {}, 11247 // int -> QUANT16_SYMM map 11248 .quant16SymmOperands = {}, 11249 // int -> FLOAT16 map 11250 .float16Operands = {}, 11251 // int -> BOOL8 map 11252 .bool8Operands = {}, 11253 // int -> QUANT8_SYMM_PER_CHANNEL map 11254 .quant8ChannelOperands = {}, 11255 // int -> QUANT16_ASYMM map 11256 .quant16AsymmOperands = {}, 11257 // int -> QUANT8_SYMM map 11258 .quant8SymmOperands = {}, 11259 }, 11260 //Output(s) 11261 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11262 // int -> Dimensions map 11263 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11264 // int -> FLOAT32 map 11265 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11266 // int -> INT32 map 11267 .int32Operands = {}, 11268 // int -> QUANT8_ASYMM map 11269 .quant8AsymmOperands = {}, 11270 // int -> QUANT16_SYMM map 11271 .quant16SymmOperands = {}, 11272 // int -> FLOAT16 map 11273 .float16Operands = {}, 11274 // int -> BOOL8 map 11275 .bool8Operands = {}, 11276 // int -> QUANT8_SYMM_PER_CHANNEL map 11277 .quant8ChannelOperands = {}, 11278 // int -> QUANT16_ASYMM map 11279 .quant16AsymmOperands = {}, 11280 // int -> QUANT8_SYMM map 11281 .quant8SymmOperands = {}, 11282 } 11283 }, 11284 }, // End of an example 11285 }; 11286 return examples_dynamic_output_shape_nchw_relu1_weight_as_input; 11287 }; 11288 11289 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_relaxed() { 11290 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_relaxed = { 11291 // Begin of an example 11292 { 11293 .operands = { 11294 //Input(s) 11295 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11296 // int -> Dimensions map 11297 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11298 // int -> FLOAT32 map 11299 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 11300 // int -> INT32 map 11301 .int32Operands = {}, 11302 // int -> QUANT8_ASYMM map 11303 .quant8AsymmOperands = {}, 11304 // int -> QUANT16_SYMM map 11305 .quant16SymmOperands = {}, 11306 // int -> FLOAT16 map 11307 .float16Operands = {}, 11308 // int -> BOOL8 map 11309 .bool8Operands = {}, 11310 // int -> QUANT8_SYMM_PER_CHANNEL map 11311 .quant8ChannelOperands = {}, 11312 // int -> QUANT16_ASYMM map 11313 .quant16AsymmOperands = {}, 11314 // int -> QUANT8_SYMM map 11315 .quant8SymmOperands = {}, 11316 }, 11317 //Output(s) 11318 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11319 // int -> Dimensions map 11320 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11321 // int -> FLOAT32 map 11322 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11323 // int -> INT32 map 11324 .int32Operands = {}, 11325 // int -> QUANT8_ASYMM map 11326 .quant8AsymmOperands = {}, 11327 // int -> QUANT16_SYMM map 11328 .quant16SymmOperands = {}, 11329 // int -> FLOAT16 map 11330 .float16Operands = {}, 11331 // int -> BOOL8 map 11332 .bool8Operands = {}, 11333 // int -> QUANT8_SYMM_PER_CHANNEL map 11334 .quant8ChannelOperands = {}, 11335 // int -> QUANT16_ASYMM map 11336 .quant16AsymmOperands = {}, 11337 // int -> QUANT8_SYMM map 11338 .quant8SymmOperands = {}, 11339 } 11340 }, 11341 }, // End of an example 11342 }; 11343 return examples_dynamic_output_shape_nchw_relu1_relaxed; 11344 }; 11345 11346 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input() { 11347 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input = { 11348 // Begin of an example 11349 { 11350 .operands = { 11351 //Input(s) 11352 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11353 // int -> Dimensions map 11354 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11355 // int -> FLOAT32 map 11356 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 11357 // int -> INT32 map 11358 .int32Operands = {}, 11359 // int -> QUANT8_ASYMM map 11360 .quant8AsymmOperands = {}, 11361 // int -> QUANT16_SYMM map 11362 .quant16SymmOperands = {}, 11363 // int -> FLOAT16 map 11364 .float16Operands = {}, 11365 // int -> BOOL8 map 11366 .bool8Operands = {}, 11367 // int -> QUANT8_SYMM_PER_CHANNEL map 11368 .quant8ChannelOperands = {}, 11369 // int -> QUANT16_ASYMM map 11370 .quant16AsymmOperands = {}, 11371 // int -> QUANT8_SYMM map 11372 .quant8SymmOperands = {}, 11373 }, 11374 //Output(s) 11375 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11376 // int -> Dimensions map 11377 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11378 // int -> FLOAT32 map 11379 .float32Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11380 // int -> INT32 map 11381 .int32Operands = {}, 11382 // int -> QUANT8_ASYMM map 11383 .quant8AsymmOperands = {}, 11384 // int -> QUANT16_SYMM map 11385 .quant16SymmOperands = {}, 11386 // int -> FLOAT16 map 11387 .float16Operands = {}, 11388 // int -> BOOL8 map 11389 .bool8Operands = {}, 11390 // int -> QUANT8_SYMM_PER_CHANNEL map 11391 .quant8ChannelOperands = {}, 11392 // int -> QUANT16_ASYMM map 11393 .quant16AsymmOperands = {}, 11394 // int -> QUANT8_SYMM map 11395 .quant8SymmOperands = {}, 11396 } 11397 }, 11398 }, // End of an example 11399 }; 11400 return examples_dynamic_output_shape_nchw_relu1_relaxed_weight_as_input; 11401 }; 11402 11403 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8() { 11404 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8 = { 11405 // Begin of an example 11406 { 11407 .operands = { 11408 //Input(s) 11409 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11410 // int -> Dimensions map 11411 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11412 // int -> FLOAT32 map 11413 .float32Operands = {}, 11414 // int -> INT32 map 11415 .int32Operands = {}, 11416 // int -> QUANT8_ASYMM map 11417 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 11418 // int -> QUANT16_SYMM map 11419 .quant16SymmOperands = {}, 11420 // int -> FLOAT16 map 11421 .float16Operands = {}, 11422 // int -> BOOL8 map 11423 .bool8Operands = {}, 11424 // int -> QUANT8_SYMM_PER_CHANNEL map 11425 .quant8ChannelOperands = {}, 11426 // int -> QUANT16_ASYMM map 11427 .quant16AsymmOperands = {}, 11428 // int -> QUANT8_SYMM map 11429 .quant8SymmOperands = {}, 11430 }, 11431 //Output(s) 11432 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11433 // int -> Dimensions map 11434 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11435 // int -> FLOAT32 map 11436 .float32Operands = {}, 11437 // int -> INT32 map 11438 .int32Operands = {}, 11439 // int -> QUANT8_ASYMM map 11440 .quant8AsymmOperands = {{0, {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 11441 // int -> QUANT16_SYMM map 11442 .quant16SymmOperands = {}, 11443 // int -> FLOAT16 map 11444 .float16Operands = {}, 11445 // int -> BOOL8 map 11446 .bool8Operands = {}, 11447 // int -> QUANT8_SYMM_PER_CHANNEL map 11448 .quant8ChannelOperands = {}, 11449 // int -> QUANT16_ASYMM map 11450 .quant16AsymmOperands = {}, 11451 // int -> QUANT8_SYMM map 11452 .quant8SymmOperands = {}, 11453 } 11454 }, 11455 }, // End of an example 11456 }; 11457 return examples_dynamic_output_shape_nchw_relu1_quant8; 11458 }; 11459 11460 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input() { 11461 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input = { 11462 // Begin of an example 11463 { 11464 .operands = { 11465 //Input(s) 11466 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11467 // int -> Dimensions map 11468 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11469 // int -> FLOAT32 map 11470 .float32Operands = {}, 11471 // int -> INT32 map 11472 .int32Operands = {{2, {-6, -8}}}, 11473 // int -> QUANT8_ASYMM map 11474 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 11475 // int -> QUANT16_SYMM map 11476 .quant16SymmOperands = {}, 11477 // int -> FLOAT16 map 11478 .float16Operands = {}, 11479 // int -> BOOL8 map 11480 .bool8Operands = {}, 11481 // int -> QUANT8_SYMM_PER_CHANNEL map 11482 .quant8ChannelOperands = {}, 11483 // int -> QUANT16_ASYMM map 11484 .quant16AsymmOperands = {}, 11485 // int -> QUANT8_SYMM map 11486 .quant8SymmOperands = {}, 11487 }, 11488 //Output(s) 11489 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11490 // int -> Dimensions map 11491 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11492 // int -> FLOAT32 map 11493 .float32Operands = {}, 11494 // int -> INT32 map 11495 .int32Operands = {}, 11496 // int -> QUANT8_ASYMM map 11497 .quant8AsymmOperands = {{0, {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}}}, 11498 // int -> QUANT16_SYMM map 11499 .quant16SymmOperands = {}, 11500 // int -> FLOAT16 map 11501 .float16Operands = {}, 11502 // int -> BOOL8 map 11503 .bool8Operands = {}, 11504 // int -> QUANT8_SYMM_PER_CHANNEL map 11505 .quant8ChannelOperands = {}, 11506 // int -> QUANT16_ASYMM map 11507 .quant16AsymmOperands = {}, 11508 // int -> QUANT8_SYMM map 11509 .quant8SymmOperands = {}, 11510 } 11511 }, 11512 }, // End of an example 11513 }; 11514 return examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input; 11515 }; 11516 11517 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_2() { 11518 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_2 = { 11519 // Begin of an example 11520 { 11521 .operands = { 11522 //Input(s) 11523 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11524 // int -> Dimensions map 11525 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11526 // int -> FLOAT32 map 11527 .float32Operands = {}, 11528 // int -> INT32 map 11529 .int32Operands = {}, 11530 // int -> QUANT8_ASYMM map 11531 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 11532 // int -> QUANT16_SYMM map 11533 .quant16SymmOperands = {}, 11534 // int -> FLOAT16 map 11535 .float16Operands = {}, 11536 // int -> BOOL8 map 11537 .bool8Operands = {}, 11538 // int -> QUANT8_SYMM_PER_CHANNEL map 11539 .quant8ChannelOperands = {}, 11540 // int -> QUANT16_ASYMM map 11541 .quant16AsymmOperands = {}, 11542 // int -> QUANT8_SYMM map 11543 .quant8SymmOperands = {}, 11544 }, 11545 //Output(s) 11546 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11547 // int -> Dimensions map 11548 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11549 // int -> FLOAT32 map 11550 .float32Operands = {}, 11551 // int -> INT32 map 11552 .int32Operands = {}, 11553 // int -> QUANT8_ASYMM map 11554 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 11555 // int -> QUANT16_SYMM map 11556 .quant16SymmOperands = {}, 11557 // int -> FLOAT16 map 11558 .float16Operands = {}, 11559 // int -> BOOL8 map 11560 .bool8Operands = {}, 11561 // int -> QUANT8_SYMM_PER_CHANNEL map 11562 .quant8ChannelOperands = {}, 11563 // int -> QUANT16_ASYMM map 11564 .quant16AsymmOperands = {}, 11565 // int -> QUANT8_SYMM map 11566 .quant8SymmOperands = {}, 11567 } 11568 }, 11569 }, // End of an example 11570 }; 11571 return examples_dynamic_output_shape_nchw_relu1_quant8_2; 11572 }; 11573 11574 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2() { 11575 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2 = { 11576 // Begin of an example 11577 { 11578 .operands = { 11579 //Input(s) 11580 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11581 // int -> Dimensions map 11582 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11583 // int -> FLOAT32 map 11584 .float32Operands = {}, 11585 // int -> INT32 map 11586 .int32Operands = {{2, {-6, -8}}}, 11587 // int -> QUANT8_ASYMM map 11588 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 11589 // int -> QUANT16_SYMM map 11590 .quant16SymmOperands = {}, 11591 // int -> FLOAT16 map 11592 .float16Operands = {}, 11593 // int -> BOOL8 map 11594 .bool8Operands = {}, 11595 // int -> QUANT8_SYMM_PER_CHANNEL map 11596 .quant8ChannelOperands = {}, 11597 // int -> QUANT16_ASYMM map 11598 .quant16AsymmOperands = {}, 11599 // int -> QUANT8_SYMM map 11600 .quant8SymmOperands = {}, 11601 }, 11602 //Output(s) 11603 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11604 // int -> Dimensions map 11605 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11606 // int -> FLOAT32 map 11607 .float32Operands = {}, 11608 // int -> INT32 map 11609 .int32Operands = {}, 11610 // int -> QUANT8_ASYMM map 11611 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 11612 // int -> QUANT16_SYMM map 11613 .quant16SymmOperands = {}, 11614 // int -> FLOAT16 map 11615 .float16Operands = {}, 11616 // int -> BOOL8 map 11617 .bool8Operands = {}, 11618 // int -> QUANT8_SYMM_PER_CHANNEL map 11619 .quant8ChannelOperands = {}, 11620 // int -> QUANT16_ASYMM map 11621 .quant16AsymmOperands = {}, 11622 // int -> QUANT8_SYMM map 11623 .quant8SymmOperands = {}, 11624 } 11625 }, 11626 }, // End of an example 11627 }; 11628 return examples_dynamic_output_shape_nchw_relu1_quant8_weight_as_input_2; 11629 }; 11630 11631 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8() { 11632 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8 = { 11633 // Begin of an example 11634 { 11635 .operands = { 11636 //Input(s) 11637 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11638 // int -> Dimensions map 11639 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11640 // int -> FLOAT32 map 11641 .float32Operands = {}, 11642 // int -> INT32 map 11643 .int32Operands = {}, 11644 // int -> QUANT8_ASYMM map 11645 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 11646 // int -> QUANT16_SYMM map 11647 .quant16SymmOperands = {}, 11648 // int -> FLOAT16 map 11649 .float16Operands = {}, 11650 // int -> BOOL8 map 11651 .bool8Operands = {}, 11652 // int -> QUANT8_SYMM_PER_CHANNEL map 11653 .quant8ChannelOperands = {}, 11654 // int -> QUANT16_ASYMM map 11655 .quant16AsymmOperands = {}, 11656 // int -> QUANT8_SYMM map 11657 .quant8SymmOperands = {}, 11658 }, 11659 //Output(s) 11660 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11661 // int -> Dimensions map 11662 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11663 // int -> FLOAT32 map 11664 .float32Operands = {}, 11665 // int -> INT32 map 11666 .int32Operands = {}, 11667 // int -> QUANT8_ASYMM map 11668 .quant8AsymmOperands = {{0, {79, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 11669 // int -> QUANT16_SYMM map 11670 .quant16SymmOperands = {}, 11671 // int -> FLOAT16 map 11672 .float16Operands = {}, 11673 // int -> BOOL8 map 11674 .bool8Operands = {}, 11675 // int -> QUANT8_SYMM_PER_CHANNEL map 11676 .quant8ChannelOperands = {}, 11677 // int -> QUANT16_ASYMM map 11678 .quant16AsymmOperands = {}, 11679 // int -> QUANT8_SYMM map 11680 .quant8SymmOperands = {}, 11681 } 11682 }, 11683 }, // End of an example 11684 }; 11685 return examples_dynamic_output_shape_nchw_relu1_channelQuant8; 11686 }; 11687 11688 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input() { 11689 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input = { 11690 // Begin of an example 11691 { 11692 .operands = { 11693 //Input(s) 11694 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11695 // int -> Dimensions map 11696 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11697 // int -> FLOAT32 map 11698 .float32Operands = {}, 11699 // int -> INT32 map 11700 .int32Operands = {{2, {-24, -16}}}, 11701 // int -> QUANT8_ASYMM map 11702 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 11703 // int -> QUANT16_SYMM map 11704 .quant16SymmOperands = {}, 11705 // int -> FLOAT16 map 11706 .float16Operands = {}, 11707 // int -> BOOL8 map 11708 .bool8Operands = {}, 11709 // int -> QUANT8_SYMM_PER_CHANNEL map 11710 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 11711 // int -> QUANT16_ASYMM map 11712 .quant16AsymmOperands = {}, 11713 // int -> QUANT8_SYMM map 11714 .quant8SymmOperands = {}, 11715 }, 11716 //Output(s) 11717 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11718 // int -> Dimensions map 11719 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11720 // int -> FLOAT32 map 11721 .float32Operands = {}, 11722 // int -> INT32 map 11723 .int32Operands = {}, 11724 // int -> QUANT8_ASYMM map 11725 .quant8AsymmOperands = {{0, {79, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 80, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82}}}, 11726 // int -> QUANT16_SYMM map 11727 .quant16SymmOperands = {}, 11728 // int -> FLOAT16 map 11729 .float16Operands = {}, 11730 // int -> BOOL8 map 11731 .bool8Operands = {}, 11732 // int -> QUANT8_SYMM_PER_CHANNEL map 11733 .quant8ChannelOperands = {}, 11734 // int -> QUANT16_ASYMM map 11735 .quant16AsymmOperands = {}, 11736 // int -> QUANT8_SYMM map 11737 .quant8SymmOperands = {}, 11738 } 11739 }, 11740 }, // End of an example 11741 }; 11742 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input; 11743 }; 11744 11745 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_2() { 11746 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_2 = { 11747 // Begin of an example 11748 { 11749 .operands = { 11750 //Input(s) 11751 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11752 // int -> Dimensions map 11753 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11754 // int -> FLOAT32 map 11755 .float32Operands = {}, 11756 // int -> INT32 map 11757 .int32Operands = {}, 11758 // int -> QUANT8_ASYMM map 11759 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 11760 // int -> QUANT16_SYMM map 11761 .quant16SymmOperands = {}, 11762 // int -> FLOAT16 map 11763 .float16Operands = {}, 11764 // int -> BOOL8 map 11765 .bool8Operands = {}, 11766 // int -> QUANT8_SYMM_PER_CHANNEL map 11767 .quant8ChannelOperands = {}, 11768 // int -> QUANT16_ASYMM map 11769 .quant16AsymmOperands = {}, 11770 // int -> QUANT8_SYMM map 11771 .quant8SymmOperands = {}, 11772 }, 11773 //Output(s) 11774 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11775 // int -> Dimensions map 11776 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11777 // int -> FLOAT32 map 11778 .float32Operands = {}, 11779 // int -> INT32 map 11780 .int32Operands = {}, 11781 // int -> QUANT8_ASYMM map 11782 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 11783 // int -> QUANT16_SYMM map 11784 .quant16SymmOperands = {}, 11785 // int -> FLOAT16 map 11786 .float16Operands = {}, 11787 // int -> BOOL8 map 11788 .bool8Operands = {}, 11789 // int -> QUANT8_SYMM_PER_CHANNEL map 11790 .quant8ChannelOperands = {}, 11791 // int -> QUANT16_ASYMM map 11792 .quant16AsymmOperands = {}, 11793 // int -> QUANT8_SYMM map 11794 .quant8SymmOperands = {}, 11795 } 11796 }, 11797 }, // End of an example 11798 }; 11799 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_2; 11800 }; 11801 11802 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2() { 11803 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2 = { 11804 // Begin of an example 11805 { 11806 .operands = { 11807 //Input(s) 11808 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11809 // int -> Dimensions map 11810 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11811 // int -> FLOAT32 map 11812 .float32Operands = {}, 11813 // int -> INT32 map 11814 .int32Operands = {{2, {-24, -16}}}, 11815 // int -> QUANT8_ASYMM map 11816 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 11817 // int -> QUANT16_SYMM map 11818 .quant16SymmOperands = {}, 11819 // int -> FLOAT16 map 11820 .float16Operands = {}, 11821 // int -> BOOL8 map 11822 .bool8Operands = {}, 11823 // int -> QUANT8_SYMM_PER_CHANNEL map 11824 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 11825 // int -> QUANT16_ASYMM map 11826 .quant16AsymmOperands = {}, 11827 // int -> QUANT8_SYMM map 11828 .quant8SymmOperands = {}, 11829 }, 11830 //Output(s) 11831 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11832 // int -> Dimensions map 11833 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11834 // int -> FLOAT32 map 11835 .float32Operands = {}, 11836 // int -> INT32 map 11837 .int32Operands = {}, 11838 // int -> QUANT8_ASYMM map 11839 .quant8AsymmOperands = {{0, {75, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 80, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90}}}, 11840 // int -> QUANT16_SYMM map 11841 .quant16SymmOperands = {}, 11842 // int -> FLOAT16 map 11843 .float16Operands = {}, 11844 // int -> BOOL8 map 11845 .bool8Operands = {}, 11846 // int -> QUANT8_SYMM_PER_CHANNEL map 11847 .quant8ChannelOperands = {}, 11848 // int -> QUANT16_ASYMM map 11849 .quant16AsymmOperands = {}, 11850 // int -> QUANT8_SYMM map 11851 .quant8SymmOperands = {}, 11852 } 11853 }, 11854 }, // End of an example 11855 }; 11856 return examples_dynamic_output_shape_nchw_relu1_channelQuant8_weight_as_input_2; 11857 }; 11858 11859 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_float16() { 11860 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_float16 = { 11861 // Begin of an example 11862 { 11863 .operands = { 11864 //Input(s) 11865 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11866 // int -> Dimensions map 11867 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11868 // int -> FLOAT32 map 11869 .float32Operands = {}, 11870 // int -> INT32 map 11871 .int32Operands = {}, 11872 // int -> QUANT8_ASYMM map 11873 .quant8AsymmOperands = {}, 11874 // int -> QUANT16_SYMM map 11875 .quant16SymmOperands = {}, 11876 // int -> FLOAT16 map 11877 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 11878 // int -> BOOL8 map 11879 .bool8Operands = {}, 11880 // int -> QUANT8_SYMM_PER_CHANNEL map 11881 .quant8ChannelOperands = {}, 11882 // int -> QUANT16_ASYMM map 11883 .quant16AsymmOperands = {}, 11884 // int -> QUANT8_SYMM map 11885 .quant8SymmOperands = {}, 11886 }, 11887 //Output(s) 11888 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11889 // int -> Dimensions map 11890 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11891 // int -> FLOAT32 map 11892 .float32Operands = {}, 11893 // int -> INT32 map 11894 .int32Operands = {}, 11895 // int -> QUANT8_ASYMM map 11896 .quant8AsymmOperands = {}, 11897 // int -> QUANT16_SYMM map 11898 .quant16SymmOperands = {}, 11899 // int -> FLOAT16 map 11900 .float16Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11901 // int -> BOOL8 map 11902 .bool8Operands = {}, 11903 // int -> QUANT8_SYMM_PER_CHANNEL map 11904 .quant8ChannelOperands = {}, 11905 // int -> QUANT16_ASYMM map 11906 .quant16AsymmOperands = {}, 11907 // int -> QUANT8_SYMM map 11908 .quant8SymmOperands = {}, 11909 } 11910 }, 11911 }, // End of an example 11912 }; 11913 return examples_dynamic_output_shape_nchw_relu1_float16; 11914 }; 11915 11916 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input() { 11917 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input = { 11918 // Begin of an example 11919 { 11920 .operands = { 11921 //Input(s) 11922 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11923 // int -> Dimensions map 11924 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 11925 // int -> FLOAT32 map 11926 .float32Operands = {}, 11927 // int -> INT32 map 11928 .int32Operands = {}, 11929 // int -> QUANT8_ASYMM map 11930 .quant8AsymmOperands = {}, 11931 // int -> QUANT16_SYMM map 11932 .quant16SymmOperands = {}, 11933 // int -> FLOAT16 map 11934 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 11935 // int -> BOOL8 map 11936 .bool8Operands = {}, 11937 // int -> QUANT8_SYMM_PER_CHANNEL map 11938 .quant8ChannelOperands = {}, 11939 // int -> QUANT16_ASYMM map 11940 .quant16AsymmOperands = {}, 11941 // int -> QUANT8_SYMM map 11942 .quant8SymmOperands = {}, 11943 }, 11944 //Output(s) 11945 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11946 // int -> Dimensions map 11947 .operandDimensions = {{0, {1, 2, 5, 5}}}, 11948 // int -> FLOAT32 map 11949 .float32Operands = {}, 11950 // int -> INT32 map 11951 .int32Operands = {}, 11952 // int -> QUANT8_ASYMM map 11953 .quant8AsymmOperands = {}, 11954 // int -> QUANT16_SYMM map 11955 .quant16SymmOperands = {}, 11956 // int -> FLOAT16 map 11957 .float16Operands = {{0, {-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}}}, 11958 // int -> BOOL8 map 11959 .bool8Operands = {}, 11960 // int -> QUANT8_SYMM_PER_CHANNEL map 11961 .quant8ChannelOperands = {}, 11962 // int -> QUANT16_ASYMM map 11963 .quant16AsymmOperands = {}, 11964 // int -> QUANT8_SYMM map 11965 .quant8SymmOperands = {}, 11966 } 11967 }, 11968 }, // End of an example 11969 }; 11970 return examples_dynamic_output_shape_nchw_relu1_float16_weight_as_input; 11971 }; 11972 11973 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6() { 11974 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6 = { 11975 // Begin of an example 11976 { 11977 .operands = { 11978 //Input(s) 11979 { // See tools/test_generator/include/TestHarness.h:MixedTyped 11980 // int -> Dimensions map 11981 .operandDimensions = {{0, {1, 1, 2, 2}}}, 11982 // int -> FLOAT32 map 11983 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 11984 // int -> INT32 map 11985 .int32Operands = {}, 11986 // int -> QUANT8_ASYMM map 11987 .quant8AsymmOperands = {}, 11988 // int -> QUANT16_SYMM map 11989 .quant16SymmOperands = {}, 11990 // int -> FLOAT16 map 11991 .float16Operands = {}, 11992 // int -> BOOL8 map 11993 .bool8Operands = {}, 11994 // int -> QUANT8_SYMM_PER_CHANNEL map 11995 .quant8ChannelOperands = {}, 11996 // int -> QUANT16_ASYMM map 11997 .quant16AsymmOperands = {}, 11998 // int -> QUANT8_SYMM map 11999 .quant8SymmOperands = {}, 12000 }, 12001 //Output(s) 12002 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12003 // int -> Dimensions map 12004 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12005 // int -> FLOAT32 map 12006 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12007 // int -> INT32 map 12008 .int32Operands = {}, 12009 // int -> QUANT8_ASYMM map 12010 .quant8AsymmOperands = {}, 12011 // int -> QUANT16_SYMM map 12012 .quant16SymmOperands = {}, 12013 // int -> FLOAT16 map 12014 .float16Operands = {}, 12015 // int -> BOOL8 map 12016 .bool8Operands = {}, 12017 // int -> QUANT8_SYMM_PER_CHANNEL map 12018 .quant8ChannelOperands = {}, 12019 // int -> QUANT16_ASYMM map 12020 .quant16AsymmOperands = {}, 12021 // int -> QUANT8_SYMM map 12022 .quant8SymmOperands = {}, 12023 } 12024 }, 12025 }, // End of an example 12026 }; 12027 return examples_dynamic_output_shape_nchw_relu6; 12028 }; 12029 12030 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_weight_as_input() { 12031 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_weight_as_input = { 12032 // Begin of an example 12033 { 12034 .operands = { 12035 //Input(s) 12036 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12037 // int -> Dimensions map 12038 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12039 // int -> FLOAT32 map 12040 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 12041 // int -> INT32 map 12042 .int32Operands = {}, 12043 // int -> QUANT8_ASYMM map 12044 .quant8AsymmOperands = {}, 12045 // int -> QUANT16_SYMM map 12046 .quant16SymmOperands = {}, 12047 // int -> FLOAT16 map 12048 .float16Operands = {}, 12049 // int -> BOOL8 map 12050 .bool8Operands = {}, 12051 // int -> QUANT8_SYMM_PER_CHANNEL map 12052 .quant8ChannelOperands = {}, 12053 // int -> QUANT16_ASYMM map 12054 .quant16AsymmOperands = {}, 12055 // int -> QUANT8_SYMM map 12056 .quant8SymmOperands = {}, 12057 }, 12058 //Output(s) 12059 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12060 // int -> Dimensions map 12061 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12062 // int -> FLOAT32 map 12063 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12064 // int -> INT32 map 12065 .int32Operands = {}, 12066 // int -> QUANT8_ASYMM map 12067 .quant8AsymmOperands = {}, 12068 // int -> QUANT16_SYMM map 12069 .quant16SymmOperands = {}, 12070 // int -> FLOAT16 map 12071 .float16Operands = {}, 12072 // int -> BOOL8 map 12073 .bool8Operands = {}, 12074 // int -> QUANT8_SYMM_PER_CHANNEL map 12075 .quant8ChannelOperands = {}, 12076 // int -> QUANT16_ASYMM map 12077 .quant16AsymmOperands = {}, 12078 // int -> QUANT8_SYMM map 12079 .quant8SymmOperands = {}, 12080 } 12081 }, 12082 }, // End of an example 12083 }; 12084 return examples_dynamic_output_shape_nchw_relu6_weight_as_input; 12085 }; 12086 12087 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_relaxed() { 12088 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_relaxed = { 12089 // Begin of an example 12090 { 12091 .operands = { 12092 //Input(s) 12093 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12094 // int -> Dimensions map 12095 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12096 // int -> FLOAT32 map 12097 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 12098 // int -> INT32 map 12099 .int32Operands = {}, 12100 // int -> QUANT8_ASYMM map 12101 .quant8AsymmOperands = {}, 12102 // int -> QUANT16_SYMM map 12103 .quant16SymmOperands = {}, 12104 // int -> FLOAT16 map 12105 .float16Operands = {}, 12106 // int -> BOOL8 map 12107 .bool8Operands = {}, 12108 // int -> QUANT8_SYMM_PER_CHANNEL map 12109 .quant8ChannelOperands = {}, 12110 // int -> QUANT16_ASYMM map 12111 .quant16AsymmOperands = {}, 12112 // int -> QUANT8_SYMM map 12113 .quant8SymmOperands = {}, 12114 }, 12115 //Output(s) 12116 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12117 // int -> Dimensions map 12118 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12119 // int -> FLOAT32 map 12120 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12121 // int -> INT32 map 12122 .int32Operands = {}, 12123 // int -> QUANT8_ASYMM map 12124 .quant8AsymmOperands = {}, 12125 // int -> QUANT16_SYMM map 12126 .quant16SymmOperands = {}, 12127 // int -> FLOAT16 map 12128 .float16Operands = {}, 12129 // int -> BOOL8 map 12130 .bool8Operands = {}, 12131 // int -> QUANT8_SYMM_PER_CHANNEL map 12132 .quant8ChannelOperands = {}, 12133 // int -> QUANT16_ASYMM map 12134 .quant16AsymmOperands = {}, 12135 // int -> QUANT8_SYMM map 12136 .quant8SymmOperands = {}, 12137 } 12138 }, 12139 }, // End of an example 12140 }; 12141 return examples_dynamic_output_shape_nchw_relu6_relaxed; 12142 }; 12143 12144 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input() { 12145 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input = { 12146 // Begin of an example 12147 { 12148 .operands = { 12149 //Input(s) 12150 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12151 // int -> Dimensions map 12152 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12153 // int -> FLOAT32 map 12154 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 12155 // int -> INT32 map 12156 .int32Operands = {}, 12157 // int -> QUANT8_ASYMM map 12158 .quant8AsymmOperands = {}, 12159 // int -> QUANT16_SYMM map 12160 .quant16SymmOperands = {}, 12161 // int -> FLOAT16 map 12162 .float16Operands = {}, 12163 // int -> BOOL8 map 12164 .bool8Operands = {}, 12165 // int -> QUANT8_SYMM_PER_CHANNEL map 12166 .quant8ChannelOperands = {}, 12167 // int -> QUANT16_ASYMM map 12168 .quant16AsymmOperands = {}, 12169 // int -> QUANT8_SYMM map 12170 .quant8SymmOperands = {}, 12171 }, 12172 //Output(s) 12173 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12174 // int -> Dimensions map 12175 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12176 // int -> FLOAT32 map 12177 .float32Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12178 // int -> INT32 map 12179 .int32Operands = {}, 12180 // int -> QUANT8_ASYMM map 12181 .quant8AsymmOperands = {}, 12182 // int -> QUANT16_SYMM map 12183 .quant16SymmOperands = {}, 12184 // int -> FLOAT16 map 12185 .float16Operands = {}, 12186 // int -> BOOL8 map 12187 .bool8Operands = {}, 12188 // int -> QUANT8_SYMM_PER_CHANNEL map 12189 .quant8ChannelOperands = {}, 12190 // int -> QUANT16_ASYMM map 12191 .quant16AsymmOperands = {}, 12192 // int -> QUANT8_SYMM map 12193 .quant8SymmOperands = {}, 12194 } 12195 }, 12196 }, // End of an example 12197 }; 12198 return examples_dynamic_output_shape_nchw_relu6_relaxed_weight_as_input; 12199 }; 12200 12201 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8() { 12202 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8 = { 12203 // Begin of an example 12204 { 12205 .operands = { 12206 //Input(s) 12207 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12208 // int -> Dimensions map 12209 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12210 // int -> FLOAT32 map 12211 .float32Operands = {}, 12212 // int -> INT32 map 12213 .int32Operands = {}, 12214 // int -> QUANT8_ASYMM map 12215 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}}, 12216 // int -> QUANT16_SYMM map 12217 .quant16SymmOperands = {}, 12218 // int -> FLOAT16 map 12219 .float16Operands = {}, 12220 // int -> BOOL8 map 12221 .bool8Operands = {}, 12222 // int -> QUANT8_SYMM_PER_CHANNEL map 12223 .quant8ChannelOperands = {}, 12224 // int -> QUANT16_ASYMM map 12225 .quant16AsymmOperands = {}, 12226 // int -> QUANT8_SYMM map 12227 .quant8SymmOperands = {}, 12228 }, 12229 //Output(s) 12230 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12231 // int -> Dimensions map 12232 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12233 // int -> FLOAT32 map 12234 .float32Operands = {}, 12235 // int -> INT32 map 12236 .int32Operands = {}, 12237 // int -> QUANT8_ASYMM map 12238 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 12239 // int -> QUANT16_SYMM map 12240 .quant16SymmOperands = {}, 12241 // int -> FLOAT16 map 12242 .float16Operands = {}, 12243 // int -> BOOL8 map 12244 .bool8Operands = {}, 12245 // int -> QUANT8_SYMM_PER_CHANNEL map 12246 .quant8ChannelOperands = {}, 12247 // int -> QUANT16_ASYMM map 12248 .quant16AsymmOperands = {}, 12249 // int -> QUANT8_SYMM map 12250 .quant8SymmOperands = {}, 12251 } 12252 }, 12253 }, // End of an example 12254 }; 12255 return examples_dynamic_output_shape_nchw_relu6_quant8; 12256 }; 12257 12258 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input() { 12259 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input = { 12260 // Begin of an example 12261 { 12262 .operands = { 12263 //Input(s) 12264 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12265 // int -> Dimensions map 12266 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12267 // int -> FLOAT32 map 12268 .float32Operands = {}, 12269 // int -> INT32 map 12270 .int32Operands = {{2, {-6, -8}}}, 12271 // int -> QUANT8_ASYMM map 12272 .quant8AsymmOperands = {{0, {2, 4, 6, 8}}, {1, {2, 6, 10, 14, 18, 22, 26, 30, 34, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 12273 // int -> QUANT16_SYMM map 12274 .quant16SymmOperands = {}, 12275 // int -> FLOAT16 map 12276 .float16Operands = {}, 12277 // int -> BOOL8 map 12278 .bool8Operands = {}, 12279 // int -> QUANT8_SYMM_PER_CHANNEL map 12280 .quant8ChannelOperands = {}, 12281 // int -> QUANT16_ASYMM map 12282 .quant16AsymmOperands = {}, 12283 // int -> QUANT8_SYMM map 12284 .quant8SymmOperands = {}, 12285 }, 12286 //Output(s) 12287 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12288 // int -> Dimensions map 12289 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12290 // int -> FLOAT32 map 12291 .float32Operands = {}, 12292 // int -> INT32 map 12293 .int32Operands = {}, 12294 // int -> QUANT8_ASYMM map 12295 .quant8AsymmOperands = {{0, {0, 3, 11, 9, 12, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 4, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12}}}, 12296 // int -> QUANT16_SYMM map 12297 .quant16SymmOperands = {}, 12298 // int -> FLOAT16 map 12299 .float16Operands = {}, 12300 // int -> BOOL8 map 12301 .bool8Operands = {}, 12302 // int -> QUANT8_SYMM_PER_CHANNEL map 12303 .quant8ChannelOperands = {}, 12304 // int -> QUANT16_ASYMM map 12305 .quant16AsymmOperands = {}, 12306 // int -> QUANT8_SYMM map 12307 .quant8SymmOperands = {}, 12308 } 12309 }, 12310 }, // End of an example 12311 }; 12312 return examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input; 12313 }; 12314 12315 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_2() { 12316 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_2 = { 12317 // Begin of an example 12318 { 12319 .operands = { 12320 //Input(s) 12321 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12322 // int -> Dimensions map 12323 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12324 // int -> FLOAT32 map 12325 .float32Operands = {}, 12326 // int -> INT32 map 12327 .int32Operands = {}, 12328 // int -> QUANT8_ASYMM map 12329 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 12330 // int -> QUANT16_SYMM map 12331 .quant16SymmOperands = {}, 12332 // int -> FLOAT16 map 12333 .float16Operands = {}, 12334 // int -> BOOL8 map 12335 .bool8Operands = {}, 12336 // int -> QUANT8_SYMM_PER_CHANNEL map 12337 .quant8ChannelOperands = {}, 12338 // int -> QUANT16_ASYMM map 12339 .quant16AsymmOperands = {}, 12340 // int -> QUANT8_SYMM map 12341 .quant8SymmOperands = {}, 12342 }, 12343 //Output(s) 12344 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12345 // int -> Dimensions map 12346 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12347 // int -> FLOAT32 map 12348 .float32Operands = {}, 12349 // int -> INT32 map 12350 .int32Operands = {}, 12351 // int -> QUANT8_ASYMM map 12352 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 12353 // int -> QUANT16_SYMM map 12354 .quant16SymmOperands = {}, 12355 // int -> FLOAT16 map 12356 .float16Operands = {}, 12357 // int -> BOOL8 map 12358 .bool8Operands = {}, 12359 // int -> QUANT8_SYMM_PER_CHANNEL map 12360 .quant8ChannelOperands = {}, 12361 // int -> QUANT16_ASYMM map 12362 .quant16AsymmOperands = {}, 12363 // int -> QUANT8_SYMM map 12364 .quant8SymmOperands = {}, 12365 } 12366 }, 12367 }, // End of an example 12368 }; 12369 return examples_dynamic_output_shape_nchw_relu6_quant8_2; 12370 }; 12371 12372 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2() { 12373 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2 = { 12374 // Begin of an example 12375 { 12376 .operands = { 12377 //Input(s) 12378 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12379 // int -> Dimensions map 12380 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12381 // int -> FLOAT32 map 12382 .float32Operands = {}, 12383 // int -> INT32 map 12384 .int32Operands = {{2, {-6, -8}}}, 12385 // int -> QUANT8_ASYMM map 12386 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {130, 134, 138, 142, 146, 150, 154, 158, 162, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 12387 // int -> QUANT16_SYMM map 12388 .quant16SymmOperands = {}, 12389 // int -> FLOAT16 map 12390 .float16Operands = {}, 12391 // int -> BOOL8 map 12392 .bool8Operands = {}, 12393 // int -> QUANT8_SYMM_PER_CHANNEL map 12394 .quant8ChannelOperands = {}, 12395 // int -> QUANT16_ASYMM map 12396 .quant16AsymmOperands = {}, 12397 // int -> QUANT8_SYMM map 12398 .quant8SymmOperands = {}, 12399 }, 12400 //Output(s) 12401 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12402 // int -> Dimensions map 12403 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12404 // int -> FLOAT32 map 12405 .float32Operands = {}, 12406 // int -> INT32 map 12407 .int32Operands = {}, 12408 // int -> QUANT8_ASYMM map 12409 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 12410 // int -> QUANT16_SYMM map 12411 .quant16SymmOperands = {}, 12412 // int -> FLOAT16 map 12413 .float16Operands = {}, 12414 // int -> BOOL8 map 12415 .bool8Operands = {}, 12416 // int -> QUANT8_SYMM_PER_CHANNEL map 12417 .quant8ChannelOperands = {}, 12418 // int -> QUANT16_ASYMM map 12419 .quant16AsymmOperands = {}, 12420 // int -> QUANT8_SYMM map 12421 .quant8SymmOperands = {}, 12422 } 12423 }, 12424 }, // End of an example 12425 }; 12426 return examples_dynamic_output_shape_nchw_relu6_quant8_weight_as_input_2; 12427 }; 12428 12429 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8() { 12430 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8 = { 12431 // Begin of an example 12432 { 12433 .operands = { 12434 //Input(s) 12435 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12436 // int -> Dimensions map 12437 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12438 // int -> FLOAT32 map 12439 .float32Operands = {}, 12440 // int -> INT32 map 12441 .int32Operands = {}, 12442 // int -> QUANT8_ASYMM map 12443 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 12444 // int -> QUANT16_SYMM map 12445 .quant16SymmOperands = {}, 12446 // int -> FLOAT16 map 12447 .float16Operands = {}, 12448 // int -> BOOL8 map 12449 .bool8Operands = {}, 12450 // int -> QUANT8_SYMM_PER_CHANNEL map 12451 .quant8ChannelOperands = {}, 12452 // int -> QUANT16_ASYMM map 12453 .quant16AsymmOperands = {}, 12454 // int -> QUANT8_SYMM map 12455 .quant8SymmOperands = {}, 12456 }, 12457 //Output(s) 12458 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12459 // int -> Dimensions map 12460 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12461 // int -> FLOAT32 map 12462 .float32Operands = {}, 12463 // int -> INT32 map 12464 .int32Operands = {}, 12465 // int -> QUANT8_ASYMM map 12466 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 80, 84, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 12467 // int -> QUANT16_SYMM map 12468 .quant16SymmOperands = {}, 12469 // int -> FLOAT16 map 12470 .float16Operands = {}, 12471 // int -> BOOL8 map 12472 .bool8Operands = {}, 12473 // int -> QUANT8_SYMM_PER_CHANNEL map 12474 .quant8ChannelOperands = {}, 12475 // int -> QUANT16_ASYMM map 12476 .quant16AsymmOperands = {}, 12477 // int -> QUANT8_SYMM map 12478 .quant8SymmOperands = {}, 12479 } 12480 }, 12481 }, // End of an example 12482 }; 12483 return examples_dynamic_output_shape_nchw_relu6_channelQuant8; 12484 }; 12485 12486 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input() { 12487 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input = { 12488 // Begin of an example 12489 { 12490 .operands = { 12491 //Input(s) 12492 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12493 // int -> Dimensions map 12494 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12495 // int -> FLOAT32 map 12496 .float32Operands = {}, 12497 // int -> INT32 map 12498 .int32Operands = {{2, {-24, -16}}}, 12499 // int -> QUANT8_ASYMM map 12500 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 12501 // int -> QUANT16_SYMM map 12502 .quant16SymmOperands = {}, 12503 // int -> FLOAT16 map 12504 .float16Operands = {}, 12505 // int -> BOOL8 map 12506 .bool8Operands = {}, 12507 // int -> QUANT8_SYMM_PER_CHANNEL map 12508 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 12509 // int -> QUANT16_ASYMM map 12510 .quant16AsymmOperands = {}, 12511 // int -> QUANT8_SYMM map 12512 .quant8SymmOperands = {}, 12513 }, 12514 //Output(s) 12515 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12516 // int -> Dimensions map 12517 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12518 // int -> FLOAT32 map 12519 .float32Operands = {}, 12520 // int -> INT32 map 12521 .int32Operands = {}, 12522 // int -> QUANT8_ASYMM map 12523 .quant8AsymmOperands = {{0, {80, 83, 91, 89, 92, 91, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 80, 84, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92}}}, 12524 // int -> QUANT16_SYMM map 12525 .quant16SymmOperands = {}, 12526 // int -> FLOAT16 map 12527 .float16Operands = {}, 12528 // int -> BOOL8 map 12529 .bool8Operands = {}, 12530 // int -> QUANT8_SYMM_PER_CHANNEL map 12531 .quant8ChannelOperands = {}, 12532 // int -> QUANT16_ASYMM map 12533 .quant16AsymmOperands = {}, 12534 // int -> QUANT8_SYMM map 12535 .quant8SymmOperands = {}, 12536 } 12537 }, 12538 }, // End of an example 12539 }; 12540 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input; 12541 }; 12542 12543 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_2() { 12544 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_2 = { 12545 // Begin of an example 12546 { 12547 .operands = { 12548 //Input(s) 12549 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12550 // int -> Dimensions map 12551 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12552 // int -> FLOAT32 map 12553 .float32Operands = {}, 12554 // int -> INT32 map 12555 .int32Operands = {}, 12556 // int -> QUANT8_ASYMM map 12557 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 12558 // int -> QUANT16_SYMM map 12559 .quant16SymmOperands = {}, 12560 // int -> FLOAT16 map 12561 .float16Operands = {}, 12562 // int -> BOOL8 map 12563 .bool8Operands = {}, 12564 // int -> QUANT8_SYMM_PER_CHANNEL map 12565 .quant8ChannelOperands = {}, 12566 // int -> QUANT16_ASYMM map 12567 .quant16AsymmOperands = {}, 12568 // int -> QUANT8_SYMM map 12569 .quant8SymmOperands = {}, 12570 }, 12571 //Output(s) 12572 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12573 // int -> Dimensions map 12574 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12575 // int -> FLOAT32 map 12576 .float32Operands = {}, 12577 // int -> INT32 map 12578 .int32Operands = {}, 12579 // int -> QUANT8_ASYMM map 12580 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 12581 // int -> QUANT16_SYMM map 12582 .quant16SymmOperands = {}, 12583 // int -> FLOAT16 map 12584 .float16Operands = {}, 12585 // int -> BOOL8 map 12586 .bool8Operands = {}, 12587 // int -> QUANT8_SYMM_PER_CHANNEL map 12588 .quant8ChannelOperands = {}, 12589 // int -> QUANT16_ASYMM map 12590 .quant16AsymmOperands = {}, 12591 // int -> QUANT8_SYMM map 12592 .quant8SymmOperands = {}, 12593 } 12594 }, 12595 }, // End of an example 12596 }; 12597 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_2; 12598 }; 12599 12600 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2() { 12601 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2 = { 12602 // Begin of an example 12603 { 12604 .operands = { 12605 //Input(s) 12606 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12607 // int -> Dimensions map 12608 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12609 // int -> FLOAT32 map 12610 .float32Operands = {}, 12611 // int -> INT32 map 12612 .int32Operands = {{2, {-24, -16}}}, 12613 // int -> QUANT8_ASYMM map 12614 .quant8AsymmOperands = {{0, {104, 108, 112, 116}}}, 12615 // int -> QUANT16_SYMM map 12616 .quant16SymmOperands = {}, 12617 // int -> FLOAT16 map 12618 .float16Operands = {}, 12619 // int -> BOOL8 map 12620 .bool8Operands = {}, 12621 // int -> QUANT8_SYMM_PER_CHANNEL map 12622 .quant8ChannelOperands = {{1, {4, 12, 20, 28, 36, 44, 52, 60, 68, 4, 8, 12, 16, 20, 24, 28, 32, 36}}}, 12623 // int -> QUANT16_ASYMM map 12624 .quant16AsymmOperands = {}, 12625 // int -> QUANT8_SYMM map 12626 .quant8SymmOperands = {}, 12627 }, 12628 //Output(s) 12629 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12630 // int -> Dimensions map 12631 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12632 // int -> FLOAT32 map 12633 .float32Operands = {}, 12634 // int -> INT32 map 12635 .int32Operands = {}, 12636 // int -> QUANT8_ASYMM map 12637 .quant8AsymmOperands = {{0, {80, 95, 135, 125, 140, 135, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 80, 100, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, 140}}}, 12638 // int -> QUANT16_SYMM map 12639 .quant16SymmOperands = {}, 12640 // int -> FLOAT16 map 12641 .float16Operands = {}, 12642 // int -> BOOL8 map 12643 .bool8Operands = {}, 12644 // int -> QUANT8_SYMM_PER_CHANNEL map 12645 .quant8ChannelOperands = {}, 12646 // int -> QUANT16_ASYMM map 12647 .quant16AsymmOperands = {}, 12648 // int -> QUANT8_SYMM map 12649 .quant8SymmOperands = {}, 12650 } 12651 }, 12652 }, // End of an example 12653 }; 12654 return examples_dynamic_output_shape_nchw_relu6_channelQuant8_weight_as_input_2; 12655 }; 12656 12657 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_float16() { 12658 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_float16 = { 12659 // Begin of an example 12660 { 12661 .operands = { 12662 //Input(s) 12663 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12664 // int -> Dimensions map 12665 .operandDimensions = {{0, {1, 1, 2, 2}}}, 12666 // int -> FLOAT32 map 12667 .float32Operands = {}, 12668 // int -> INT32 map 12669 .int32Operands = {}, 12670 // int -> QUANT8_ASYMM map 12671 .quant8AsymmOperands = {}, 12672 // int -> QUANT16_SYMM map 12673 .quant16SymmOperands = {}, 12674 // int -> FLOAT16 map 12675 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 12676 // int -> BOOL8 map 12677 .bool8Operands = {}, 12678 // int -> QUANT8_SYMM_PER_CHANNEL map 12679 .quant8ChannelOperands = {}, 12680 // int -> QUANT16_ASYMM map 12681 .quant16AsymmOperands = {}, 12682 // int -> QUANT8_SYMM map 12683 .quant8SymmOperands = {}, 12684 }, 12685 //Output(s) 12686 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12687 // int -> Dimensions map 12688 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12689 // int -> FLOAT32 map 12690 .float32Operands = {}, 12691 // int -> INT32 map 12692 .int32Operands = {}, 12693 // int -> QUANT8_ASYMM map 12694 .quant8AsymmOperands = {}, 12695 // int -> QUANT16_SYMM map 12696 .quant16SymmOperands = {}, 12697 // int -> FLOAT16 map 12698 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12699 // int -> BOOL8 map 12700 .bool8Operands = {}, 12701 // int -> QUANT8_SYMM_PER_CHANNEL map 12702 .quant8ChannelOperands = {}, 12703 // int -> QUANT16_ASYMM map 12704 .quant16AsymmOperands = {}, 12705 // int -> QUANT8_SYMM map 12706 .quant8SymmOperands = {}, 12707 } 12708 }, 12709 }, // End of an example 12710 }; 12711 return examples_dynamic_output_shape_nchw_relu6_float16; 12712 }; 12713 12714 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input() { 12715 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input = { 12716 // Begin of an example 12717 { 12718 .operands = { 12719 //Input(s) 12720 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12721 // int -> Dimensions map 12722 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {2, 3, 3, 1}}, {2, {2}}}, 12723 // int -> FLOAT32 map 12724 .float32Operands = {}, 12725 // int -> INT32 map 12726 .int32Operands = {}, 12727 // int -> QUANT8_ASYMM map 12728 .quant8AsymmOperands = {}, 12729 // int -> QUANT16_SYMM map 12730 .quant16SymmOperands = {}, 12731 // int -> FLOAT16 map 12732 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f}}, {2, {-1.5f, -2.0f}}}, 12733 // int -> BOOL8 map 12734 .bool8Operands = {}, 12735 // int -> QUANT8_SYMM_PER_CHANNEL map 12736 .quant8ChannelOperands = {}, 12737 // int -> QUANT16_ASYMM map 12738 .quant16AsymmOperands = {}, 12739 // int -> QUANT8_SYMM map 12740 .quant8SymmOperands = {}, 12741 }, 12742 //Output(s) 12743 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12744 // int -> Dimensions map 12745 .operandDimensions = {{0, {1, 2, 5, 5}}}, 12746 // int -> FLOAT32 map 12747 .float32Operands = {}, 12748 // int -> INT32 map 12749 .int32Operands = {}, 12750 // int -> QUANT8_ASYMM map 12751 .quant8AsymmOperands = {}, 12752 // int -> QUANT16_SYMM map 12753 .quant16SymmOperands = {}, 12754 // int -> FLOAT16 map 12755 .float16Operands = {{0, {0.0f, 1.5f, 5.5f, 4.5f, 6.0f, 5.5f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 0.0f, 2.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f, 6.0f}}}, 12756 // int -> BOOL8 map 12757 .bool8Operands = {}, 12758 // int -> QUANT8_SYMM_PER_CHANNEL map 12759 .quant8ChannelOperands = {}, 12760 // int -> QUANT16_ASYMM map 12761 .quant16AsymmOperands = {}, 12762 // int -> QUANT8_SYMM map 12763 .quant8SymmOperands = {}, 12764 } 12765 }, 12766 }, // End of an example 12767 }; 12768 return examples_dynamic_output_shape_nchw_relu6_float16_weight_as_input; 12769 }; 12770 12771 std::vector<MixedTypedExample>& get_examples_nhwc() { 12772 static std::vector<MixedTypedExample> examples_nhwc = { 12773 // Begin of an example 12774 { 12775 .operands = { 12776 //Input(s) 12777 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12778 // int -> Dimensions map 12779 .operandDimensions = {{0, {1, 1, 2, 1}}}, 12780 // int -> FLOAT32 map 12781 .float32Operands = {{0, {300.0f, 500.0f}}}, 12782 // int -> INT32 map 12783 .int32Operands = {}, 12784 // int -> QUANT8_ASYMM map 12785 .quant8AsymmOperands = {}, 12786 // int -> QUANT16_SYMM map 12787 .quant16SymmOperands = {}, 12788 // int -> FLOAT16 map 12789 .float16Operands = {}, 12790 // int -> BOOL8 map 12791 .bool8Operands = {}, 12792 // int -> QUANT8_SYMM_PER_CHANNEL map 12793 .quant8ChannelOperands = {}, 12794 // int -> QUANT16_ASYMM map 12795 .quant16AsymmOperands = {}, 12796 // int -> QUANT8_SYMM map 12797 .quant8SymmOperands = {}, 12798 }, 12799 //Output(s) 12800 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12801 // int -> Dimensions map 12802 .operandDimensions = {{0, {1, 3, 4, 1}}}, 12803 // int -> FLOAT32 map 12804 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 12805 // int -> INT32 map 12806 .int32Operands = {}, 12807 // int -> QUANT8_ASYMM map 12808 .quant8AsymmOperands = {}, 12809 // int -> QUANT16_SYMM map 12810 .quant16SymmOperands = {}, 12811 // int -> FLOAT16 map 12812 .float16Operands = {}, 12813 // int -> BOOL8 map 12814 .bool8Operands = {}, 12815 // int -> QUANT8_SYMM_PER_CHANNEL map 12816 .quant8ChannelOperands = {}, 12817 // int -> QUANT16_ASYMM map 12818 .quant16AsymmOperands = {}, 12819 // int -> QUANT8_SYMM map 12820 .quant8SymmOperands = {}, 12821 } 12822 }, 12823 }, // End of an example 12824 }; 12825 return examples_nhwc; 12826 }; 12827 12828 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input() { 12829 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input = { 12830 // Begin of an example 12831 { 12832 .operands = { 12833 //Input(s) 12834 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12835 // int -> Dimensions map 12836 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 12837 // int -> FLOAT32 map 12838 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 12839 // int -> INT32 map 12840 .int32Operands = {}, 12841 // int -> QUANT8_ASYMM map 12842 .quant8AsymmOperands = {}, 12843 // int -> QUANT16_SYMM map 12844 .quant16SymmOperands = {}, 12845 // int -> FLOAT16 map 12846 .float16Operands = {}, 12847 // int -> BOOL8 map 12848 .bool8Operands = {}, 12849 // int -> QUANT8_SYMM_PER_CHANNEL map 12850 .quant8ChannelOperands = {}, 12851 // int -> QUANT16_ASYMM map 12852 .quant16AsymmOperands = {}, 12853 // int -> QUANT8_SYMM map 12854 .quant8SymmOperands = {}, 12855 }, 12856 //Output(s) 12857 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12858 // int -> Dimensions map 12859 .operandDimensions = {{0, {1, 3, 4, 1}}}, 12860 // int -> FLOAT32 map 12861 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 12862 // int -> INT32 map 12863 .int32Operands = {}, 12864 // int -> QUANT8_ASYMM map 12865 .quant8AsymmOperands = {}, 12866 // int -> QUANT16_SYMM map 12867 .quant16SymmOperands = {}, 12868 // int -> FLOAT16 map 12869 .float16Operands = {}, 12870 // int -> BOOL8 map 12871 .bool8Operands = {}, 12872 // int -> QUANT8_SYMM_PER_CHANNEL map 12873 .quant8ChannelOperands = {}, 12874 // int -> QUANT16_ASYMM map 12875 .quant16AsymmOperands = {}, 12876 // int -> QUANT8_SYMM map 12877 .quant8SymmOperands = {}, 12878 } 12879 }, 12880 }, // End of an example 12881 }; 12882 return examples_nhwc_weight_as_input; 12883 }; 12884 12885 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed() { 12886 static std::vector<MixedTypedExample> examples_nhwc_relaxed = { 12887 // Begin of an example 12888 { 12889 .operands = { 12890 //Input(s) 12891 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12892 // int -> Dimensions map 12893 .operandDimensions = {{0, {1, 1, 2, 1}}}, 12894 // int -> FLOAT32 map 12895 .float32Operands = {{0, {300.0f, 500.0f}}}, 12896 // int -> INT32 map 12897 .int32Operands = {}, 12898 // int -> QUANT8_ASYMM map 12899 .quant8AsymmOperands = {}, 12900 // int -> QUANT16_SYMM map 12901 .quant16SymmOperands = {}, 12902 // int -> FLOAT16 map 12903 .float16Operands = {}, 12904 // int -> BOOL8 map 12905 .bool8Operands = {}, 12906 // int -> QUANT8_SYMM_PER_CHANNEL map 12907 .quant8ChannelOperands = {}, 12908 // int -> QUANT16_ASYMM map 12909 .quant16AsymmOperands = {}, 12910 // int -> QUANT8_SYMM map 12911 .quant8SymmOperands = {}, 12912 }, 12913 //Output(s) 12914 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12915 // int -> Dimensions map 12916 .operandDimensions = {{0, {1, 3, 4, 1}}}, 12917 // int -> FLOAT32 map 12918 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 12919 // int -> INT32 map 12920 .int32Operands = {}, 12921 // int -> QUANT8_ASYMM map 12922 .quant8AsymmOperands = {}, 12923 // int -> QUANT16_SYMM map 12924 .quant16SymmOperands = {}, 12925 // int -> FLOAT16 map 12926 .float16Operands = {}, 12927 // int -> BOOL8 map 12928 .bool8Operands = {}, 12929 // int -> QUANT8_SYMM_PER_CHANNEL map 12930 .quant8ChannelOperands = {}, 12931 // int -> QUANT16_ASYMM map 12932 .quant16AsymmOperands = {}, 12933 // int -> QUANT8_SYMM map 12934 .quant8SymmOperands = {}, 12935 } 12936 }, 12937 }, // End of an example 12938 }; 12939 return examples_nhwc_relaxed; 12940 }; 12941 12942 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_weight_as_input() { 12943 static std::vector<MixedTypedExample> examples_nhwc_relaxed_weight_as_input = { 12944 // Begin of an example 12945 { 12946 .operands = { 12947 //Input(s) 12948 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12949 // int -> Dimensions map 12950 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 12951 // int -> FLOAT32 map 12952 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 12953 // int -> INT32 map 12954 .int32Operands = {}, 12955 // int -> QUANT8_ASYMM map 12956 .quant8AsymmOperands = {}, 12957 // int -> QUANT16_SYMM map 12958 .quant16SymmOperands = {}, 12959 // int -> FLOAT16 map 12960 .float16Operands = {}, 12961 // int -> BOOL8 map 12962 .bool8Operands = {}, 12963 // int -> QUANT8_SYMM_PER_CHANNEL map 12964 .quant8ChannelOperands = {}, 12965 // int -> QUANT16_ASYMM map 12966 .quant16AsymmOperands = {}, 12967 // int -> QUANT8_SYMM map 12968 .quant8SymmOperands = {}, 12969 }, 12970 //Output(s) 12971 { // See tools/test_generator/include/TestHarness.h:MixedTyped 12972 // int -> Dimensions map 12973 .operandDimensions = {{0, {1, 3, 4, 1}}}, 12974 // int -> FLOAT32 map 12975 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 12976 // int -> INT32 map 12977 .int32Operands = {}, 12978 // int -> QUANT8_ASYMM map 12979 .quant8AsymmOperands = {}, 12980 // int -> QUANT16_SYMM map 12981 .quant16SymmOperands = {}, 12982 // int -> FLOAT16 map 12983 .float16Operands = {}, 12984 // int -> BOOL8 map 12985 .bool8Operands = {}, 12986 // int -> QUANT8_SYMM_PER_CHANNEL map 12987 .quant8ChannelOperands = {}, 12988 // int -> QUANT16_ASYMM map 12989 .quant16AsymmOperands = {}, 12990 // int -> QUANT8_SYMM map 12991 .quant8SymmOperands = {}, 12992 } 12993 }, 12994 }, // End of an example 12995 }; 12996 return examples_nhwc_relaxed_weight_as_input; 12997 }; 12998 12999 std::vector<MixedTypedExample>& get_examples_nhwc_quant8() { 13000 static std::vector<MixedTypedExample> examples_nhwc_quant8 = { 13001 // Begin of an example 13002 { 13003 .operands = { 13004 //Input(s) 13005 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13006 // int -> Dimensions map 13007 .operandDimensions = {{0, {1, 1, 2, 1}}}, 13008 // int -> FLOAT32 map 13009 .float32Operands = {}, 13010 // int -> INT32 map 13011 .int32Operands = {}, 13012 // int -> QUANT8_ASYMM map 13013 .quant8AsymmOperands = {{0, {150, 250}}}, 13014 // int -> QUANT16_SYMM map 13015 .quant16SymmOperands = {}, 13016 // int -> FLOAT16 map 13017 .float16Operands = {}, 13018 // int -> BOOL8 map 13019 .bool8Operands = {}, 13020 // int -> QUANT8_SYMM_PER_CHANNEL map 13021 .quant8ChannelOperands = {}, 13022 // int -> QUANT16_ASYMM map 13023 .quant16AsymmOperands = {}, 13024 // int -> QUANT8_SYMM map 13025 .quant8SymmOperands = {}, 13026 }, 13027 //Output(s) 13028 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13029 // int -> Dimensions map 13030 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13031 // int -> FLOAT32 map 13032 .float32Operands = {}, 13033 // int -> INT32 map 13034 .int32Operands = {}, 13035 // int -> QUANT8_ASYMM map 13036 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13037 // int -> QUANT16_SYMM map 13038 .quant16SymmOperands = {}, 13039 // int -> FLOAT16 map 13040 .float16Operands = {}, 13041 // int -> BOOL8 map 13042 .bool8Operands = {}, 13043 // int -> QUANT8_SYMM_PER_CHANNEL map 13044 .quant8ChannelOperands = {}, 13045 // int -> QUANT16_ASYMM map 13046 .quant16AsymmOperands = {}, 13047 // int -> QUANT8_SYMM map 13048 .quant8SymmOperands = {}, 13049 } 13050 }, 13051 }, // End of an example 13052 }; 13053 return examples_nhwc_quant8; 13054 }; 13055 13056 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_weight_as_input() { 13057 static std::vector<MixedTypedExample> examples_nhwc_quant8_weight_as_input = { 13058 // Begin of an example 13059 { 13060 .operands = { 13061 //Input(s) 13062 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13063 // int -> Dimensions map 13064 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13065 // int -> FLOAT32 map 13066 .float32Operands = {}, 13067 // int -> INT32 map 13068 .int32Operands = {{2, {-2000}}}, 13069 // int -> QUANT8_ASYMM map 13070 .quant8AsymmOperands = {{0, {150, 250}}, {1, {164, 148, 152, 164, 160, 148, 140, 132, 144}}}, 13071 // int -> QUANT16_SYMM map 13072 .quant16SymmOperands = {}, 13073 // int -> FLOAT16 map 13074 .float16Operands = {}, 13075 // int -> BOOL8 map 13076 .bool8Operands = {}, 13077 // int -> QUANT8_SYMM_PER_CHANNEL map 13078 .quant8ChannelOperands = {}, 13079 // int -> QUANT16_ASYMM map 13080 .quant16AsymmOperands = {}, 13081 // int -> QUANT8_SYMM map 13082 .quant8SymmOperands = {}, 13083 }, 13084 //Output(s) 13085 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13086 // int -> Dimensions map 13087 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13088 // int -> FLOAT32 map 13089 .float32Operands = {}, 13090 // int -> INT32 map 13091 .int32Operands = {}, 13092 // int -> QUANT8_ASYMM map 13093 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13094 // int -> QUANT16_SYMM map 13095 .quant16SymmOperands = {}, 13096 // int -> FLOAT16 map 13097 .float16Operands = {}, 13098 // int -> BOOL8 map 13099 .bool8Operands = {}, 13100 // int -> QUANT8_SYMM_PER_CHANNEL map 13101 .quant8ChannelOperands = {}, 13102 // int -> QUANT16_ASYMM map 13103 .quant16AsymmOperands = {}, 13104 // int -> QUANT8_SYMM map 13105 .quant8SymmOperands = {}, 13106 } 13107 }, 13108 }, // End of an example 13109 }; 13110 return examples_nhwc_quant8_weight_as_input; 13111 }; 13112 13113 std::vector<MixedTypedExample>& get_examples_nhwc_channelQuant8() { 13114 static std::vector<MixedTypedExample> examples_nhwc_channelQuant8 = { 13115 // Begin of an example 13116 { 13117 .operands = { 13118 //Input(s) 13119 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13120 // int -> Dimensions map 13121 .operandDimensions = {{0, {1, 1, 2, 1}}}, 13122 // int -> FLOAT32 map 13123 .float32Operands = {}, 13124 // int -> INT32 map 13125 .int32Operands = {}, 13126 // int -> QUANT8_ASYMM map 13127 .quant8AsymmOperands = {{0, {150, 250}}}, 13128 // int -> QUANT16_SYMM map 13129 .quant16SymmOperands = {}, 13130 // int -> FLOAT16 map 13131 .float16Operands = {}, 13132 // int -> BOOL8 map 13133 .bool8Operands = {}, 13134 // int -> QUANT8_SYMM_PER_CHANNEL map 13135 .quant8ChannelOperands = {}, 13136 // int -> QUANT16_ASYMM map 13137 .quant16AsymmOperands = {}, 13138 // int -> QUANT8_SYMM map 13139 .quant8SymmOperands = {}, 13140 }, 13141 //Output(s) 13142 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13143 // int -> Dimensions map 13144 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13145 // int -> FLOAT32 map 13146 .float32Operands = {}, 13147 // int -> INT32 map 13148 .int32Operands = {}, 13149 // int -> QUANT8_ASYMM map 13150 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13151 // int -> QUANT16_SYMM map 13152 .quant16SymmOperands = {}, 13153 // int -> FLOAT16 map 13154 .float16Operands = {}, 13155 // int -> BOOL8 map 13156 .bool8Operands = {}, 13157 // int -> QUANT8_SYMM_PER_CHANNEL map 13158 .quant8ChannelOperands = {}, 13159 // int -> QUANT16_ASYMM map 13160 .quant16AsymmOperands = {}, 13161 // int -> QUANT8_SYMM map 13162 .quant8SymmOperands = {}, 13163 } 13164 }, 13165 }, // End of an example 13166 }; 13167 return examples_nhwc_channelQuant8; 13168 }; 13169 13170 std::vector<MixedTypedExample>& get_examples_nhwc_channelQuant8_weight_as_input() { 13171 static std::vector<MixedTypedExample> examples_nhwc_channelQuant8_weight_as_input = { 13172 // Begin of an example 13173 { 13174 .operands = { 13175 //Input(s) 13176 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13177 // int -> Dimensions map 13178 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13179 // int -> FLOAT32 map 13180 .float32Operands = {}, 13181 // int -> INT32 map 13182 .int32Operands = {{2, {-2000}}}, 13183 // int -> QUANT8_ASYMM map 13184 .quant8AsymmOperands = {{0, {150, 250}}}, 13185 // int -> QUANT16_SYMM map 13186 .quant16SymmOperands = {}, 13187 // int -> FLOAT16 map 13188 .float16Operands = {}, 13189 // int -> BOOL8 map 13190 .bool8Operands = {}, 13191 // int -> QUANT8_SYMM_PER_CHANNEL map 13192 .quant8ChannelOperands = {{1, {36, 20, 24, 36, 32, 20, 12, 4, 16}}}, 13193 // int -> QUANT16_ASYMM map 13194 .quant16AsymmOperands = {}, 13195 // int -> QUANT8_SYMM map 13196 .quant8SymmOperands = {}, 13197 }, 13198 //Output(s) 13199 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13200 // int -> Dimensions map 13201 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13202 // int -> FLOAT32 map 13203 .float32Operands = {}, 13204 // int -> INT32 map 13205 .int32Operands = {}, 13206 // int -> QUANT8_ASYMM map 13207 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13208 // int -> QUANT16_SYMM map 13209 .quant16SymmOperands = {}, 13210 // int -> FLOAT16 map 13211 .float16Operands = {}, 13212 // int -> BOOL8 map 13213 .bool8Operands = {}, 13214 // int -> QUANT8_SYMM_PER_CHANNEL map 13215 .quant8ChannelOperands = {}, 13216 // int -> QUANT16_ASYMM map 13217 .quant16AsymmOperands = {}, 13218 // int -> QUANT8_SYMM map 13219 .quant8SymmOperands = {}, 13220 } 13221 }, 13222 }, // End of an example 13223 }; 13224 return examples_nhwc_channelQuant8_weight_as_input; 13225 }; 13226 13227 std::vector<MixedTypedExample>& get_examples_nhwc_float16() { 13228 static std::vector<MixedTypedExample> examples_nhwc_float16 = { 13229 // Begin of an example 13230 { 13231 .operands = { 13232 //Input(s) 13233 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13234 // int -> Dimensions map 13235 .operandDimensions = {{0, {1, 1, 2, 1}}}, 13236 // int -> FLOAT32 map 13237 .float32Operands = {}, 13238 // int -> INT32 map 13239 .int32Operands = {}, 13240 // int -> QUANT8_ASYMM map 13241 .quant8AsymmOperands = {}, 13242 // int -> QUANT16_SYMM map 13243 .quant16SymmOperands = {}, 13244 // int -> FLOAT16 map 13245 .float16Operands = {{0, {300.0f, 500.0f}}}, 13246 // int -> BOOL8 map 13247 .bool8Operands = {}, 13248 // int -> QUANT8_SYMM_PER_CHANNEL map 13249 .quant8ChannelOperands = {}, 13250 // int -> QUANT16_ASYMM map 13251 .quant16AsymmOperands = {}, 13252 // int -> QUANT8_SYMM map 13253 .quant8SymmOperands = {}, 13254 }, 13255 //Output(s) 13256 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13257 // int -> Dimensions map 13258 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13259 // int -> FLOAT32 map 13260 .float32Operands = {}, 13261 // int -> INT32 map 13262 .int32Operands = {}, 13263 // int -> QUANT8_ASYMM map 13264 .quant8AsymmOperands = {}, 13265 // int -> QUANT16_SYMM map 13266 .quant16SymmOperands = {}, 13267 // int -> FLOAT16 map 13268 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13269 // int -> BOOL8 map 13270 .bool8Operands = {}, 13271 // int -> QUANT8_SYMM_PER_CHANNEL map 13272 .quant8ChannelOperands = {}, 13273 // int -> QUANT16_ASYMM map 13274 .quant16AsymmOperands = {}, 13275 // int -> QUANT8_SYMM map 13276 .quant8SymmOperands = {}, 13277 } 13278 }, 13279 }, // End of an example 13280 }; 13281 return examples_nhwc_float16; 13282 }; 13283 13284 std::vector<MixedTypedExample>& get_examples_nhwc_float16_weight_as_input() { 13285 static std::vector<MixedTypedExample> examples_nhwc_float16_weight_as_input = { 13286 // Begin of an example 13287 { 13288 .operands = { 13289 //Input(s) 13290 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13291 // int -> Dimensions map 13292 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13293 // int -> FLOAT32 map 13294 .float32Operands = {}, 13295 // int -> INT32 map 13296 .int32Operands = {}, 13297 // int -> QUANT8_ASYMM map 13298 .quant8AsymmOperands = {}, 13299 // int -> QUANT16_SYMM map 13300 .quant16SymmOperands = {}, 13301 // int -> FLOAT16 map 13302 .float16Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 13303 // int -> BOOL8 map 13304 .bool8Operands = {}, 13305 // int -> QUANT8_SYMM_PER_CHANNEL map 13306 .quant8ChannelOperands = {}, 13307 // int -> QUANT16_ASYMM map 13308 .quant16AsymmOperands = {}, 13309 // int -> QUANT8_SYMM map 13310 .quant8SymmOperands = {}, 13311 }, 13312 //Output(s) 13313 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13314 // int -> Dimensions map 13315 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13316 // int -> FLOAT32 map 13317 .float32Operands = {}, 13318 // int -> INT32 map 13319 .int32Operands = {}, 13320 // int -> QUANT8_ASYMM map 13321 .quant8AsymmOperands = {}, 13322 // int -> QUANT16_SYMM map 13323 .quant16SymmOperands = {}, 13324 // int -> FLOAT16 map 13325 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13326 // int -> BOOL8 map 13327 .bool8Operands = {}, 13328 // int -> QUANT8_SYMM_PER_CHANNEL map 13329 .quant8ChannelOperands = {}, 13330 // int -> QUANT16_ASYMM map 13331 .quant16AsymmOperands = {}, 13332 // int -> QUANT8_SYMM map 13333 .quant8SymmOperands = {}, 13334 } 13335 }, 13336 }, // End of an example 13337 }; 13338 return examples_nhwc_float16_weight_as_input; 13339 }; 13340 13341 std::vector<MixedTypedExample>& get_examples_nchw() { 13342 static std::vector<MixedTypedExample> examples_nchw = { 13343 // Begin of an example 13344 { 13345 .operands = { 13346 //Input(s) 13347 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13348 // int -> Dimensions map 13349 .operandDimensions = {{0, {1, 1, 1, 2}}}, 13350 // int -> FLOAT32 map 13351 .float32Operands = {{0, {300.0f, 500.0f}}}, 13352 // int -> INT32 map 13353 .int32Operands = {}, 13354 // int -> QUANT8_ASYMM map 13355 .quant8AsymmOperands = {}, 13356 // int -> QUANT16_SYMM map 13357 .quant16SymmOperands = {}, 13358 // int -> FLOAT16 map 13359 .float16Operands = {}, 13360 // int -> BOOL8 map 13361 .bool8Operands = {}, 13362 // int -> QUANT8_SYMM_PER_CHANNEL map 13363 .quant8ChannelOperands = {}, 13364 // int -> QUANT16_ASYMM map 13365 .quant16AsymmOperands = {}, 13366 // int -> QUANT8_SYMM map 13367 .quant8SymmOperands = {}, 13368 }, 13369 //Output(s) 13370 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13371 // int -> Dimensions map 13372 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13373 // int -> FLOAT32 map 13374 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13375 // int -> INT32 map 13376 .int32Operands = {}, 13377 // int -> QUANT8_ASYMM map 13378 .quant8AsymmOperands = {}, 13379 // int -> QUANT16_SYMM map 13380 .quant16SymmOperands = {}, 13381 // int -> FLOAT16 map 13382 .float16Operands = {}, 13383 // int -> BOOL8 map 13384 .bool8Operands = {}, 13385 // int -> QUANT8_SYMM_PER_CHANNEL map 13386 .quant8ChannelOperands = {}, 13387 // int -> QUANT16_ASYMM map 13388 .quant16AsymmOperands = {}, 13389 // int -> QUANT8_SYMM map 13390 .quant8SymmOperands = {}, 13391 } 13392 }, 13393 }, // End of an example 13394 }; 13395 return examples_nchw; 13396 }; 13397 13398 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input() { 13399 static std::vector<MixedTypedExample> examples_nchw_weight_as_input = { 13400 // Begin of an example 13401 { 13402 .operands = { 13403 //Input(s) 13404 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13405 // int -> Dimensions map 13406 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13407 // int -> FLOAT32 map 13408 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 13409 // int -> INT32 map 13410 .int32Operands = {}, 13411 // int -> QUANT8_ASYMM map 13412 .quant8AsymmOperands = {}, 13413 // int -> QUANT16_SYMM map 13414 .quant16SymmOperands = {}, 13415 // int -> FLOAT16 map 13416 .float16Operands = {}, 13417 // int -> BOOL8 map 13418 .bool8Operands = {}, 13419 // int -> QUANT8_SYMM_PER_CHANNEL map 13420 .quant8ChannelOperands = {}, 13421 // int -> QUANT16_ASYMM map 13422 .quant16AsymmOperands = {}, 13423 // int -> QUANT8_SYMM map 13424 .quant8SymmOperands = {}, 13425 }, 13426 //Output(s) 13427 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13428 // int -> Dimensions map 13429 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13430 // int -> FLOAT32 map 13431 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13432 // int -> INT32 map 13433 .int32Operands = {}, 13434 // int -> QUANT8_ASYMM map 13435 .quant8AsymmOperands = {}, 13436 // int -> QUANT16_SYMM map 13437 .quant16SymmOperands = {}, 13438 // int -> FLOAT16 map 13439 .float16Operands = {}, 13440 // int -> BOOL8 map 13441 .bool8Operands = {}, 13442 // int -> QUANT8_SYMM_PER_CHANNEL map 13443 .quant8ChannelOperands = {}, 13444 // int -> QUANT16_ASYMM map 13445 .quant16AsymmOperands = {}, 13446 // int -> QUANT8_SYMM map 13447 .quant8SymmOperands = {}, 13448 } 13449 }, 13450 }, // End of an example 13451 }; 13452 return examples_nchw_weight_as_input; 13453 }; 13454 13455 std::vector<MixedTypedExample>& get_examples_nchw_relaxed() { 13456 static std::vector<MixedTypedExample> examples_nchw_relaxed = { 13457 // Begin of an example 13458 { 13459 .operands = { 13460 //Input(s) 13461 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13462 // int -> Dimensions map 13463 .operandDimensions = {{0, {1, 1, 1, 2}}}, 13464 // int -> FLOAT32 map 13465 .float32Operands = {{0, {300.0f, 500.0f}}}, 13466 // int -> INT32 map 13467 .int32Operands = {}, 13468 // int -> QUANT8_ASYMM map 13469 .quant8AsymmOperands = {}, 13470 // int -> QUANT16_SYMM map 13471 .quant16SymmOperands = {}, 13472 // int -> FLOAT16 map 13473 .float16Operands = {}, 13474 // int -> BOOL8 map 13475 .bool8Operands = {}, 13476 // int -> QUANT8_SYMM_PER_CHANNEL map 13477 .quant8ChannelOperands = {}, 13478 // int -> QUANT16_ASYMM map 13479 .quant16AsymmOperands = {}, 13480 // int -> QUANT8_SYMM map 13481 .quant8SymmOperands = {}, 13482 }, 13483 //Output(s) 13484 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13485 // int -> Dimensions map 13486 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13487 // int -> FLOAT32 map 13488 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13489 // int -> INT32 map 13490 .int32Operands = {}, 13491 // int -> QUANT8_ASYMM map 13492 .quant8AsymmOperands = {}, 13493 // int -> QUANT16_SYMM map 13494 .quant16SymmOperands = {}, 13495 // int -> FLOAT16 map 13496 .float16Operands = {}, 13497 // int -> BOOL8 map 13498 .bool8Operands = {}, 13499 // int -> QUANT8_SYMM_PER_CHANNEL map 13500 .quant8ChannelOperands = {}, 13501 // int -> QUANT16_ASYMM map 13502 .quant16AsymmOperands = {}, 13503 // int -> QUANT8_SYMM map 13504 .quant8SymmOperands = {}, 13505 } 13506 }, 13507 }, // End of an example 13508 }; 13509 return examples_nchw_relaxed; 13510 }; 13511 13512 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_weight_as_input() { 13513 static std::vector<MixedTypedExample> examples_nchw_relaxed_weight_as_input = { 13514 // Begin of an example 13515 { 13516 .operands = { 13517 //Input(s) 13518 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13519 // int -> Dimensions map 13520 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13521 // int -> FLOAT32 map 13522 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 13523 // int -> INT32 map 13524 .int32Operands = {}, 13525 // int -> QUANT8_ASYMM map 13526 .quant8AsymmOperands = {}, 13527 // int -> QUANT16_SYMM map 13528 .quant16SymmOperands = {}, 13529 // int -> FLOAT16 map 13530 .float16Operands = {}, 13531 // int -> BOOL8 map 13532 .bool8Operands = {}, 13533 // int -> QUANT8_SYMM_PER_CHANNEL map 13534 .quant8ChannelOperands = {}, 13535 // int -> QUANT16_ASYMM map 13536 .quant16AsymmOperands = {}, 13537 // int -> QUANT8_SYMM map 13538 .quant8SymmOperands = {}, 13539 }, 13540 //Output(s) 13541 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13542 // int -> Dimensions map 13543 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13544 // int -> FLOAT32 map 13545 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13546 // int -> INT32 map 13547 .int32Operands = {}, 13548 // int -> QUANT8_ASYMM map 13549 .quant8AsymmOperands = {}, 13550 // int -> QUANT16_SYMM map 13551 .quant16SymmOperands = {}, 13552 // int -> FLOAT16 map 13553 .float16Operands = {}, 13554 // int -> BOOL8 map 13555 .bool8Operands = {}, 13556 // int -> QUANT8_SYMM_PER_CHANNEL map 13557 .quant8ChannelOperands = {}, 13558 // int -> QUANT16_ASYMM map 13559 .quant16AsymmOperands = {}, 13560 // int -> QUANT8_SYMM map 13561 .quant8SymmOperands = {}, 13562 } 13563 }, 13564 }, // End of an example 13565 }; 13566 return examples_nchw_relaxed_weight_as_input; 13567 }; 13568 13569 std::vector<MixedTypedExample>& get_examples_nchw_quant8() { 13570 static std::vector<MixedTypedExample> examples_nchw_quant8 = { 13571 // Begin of an example 13572 { 13573 .operands = { 13574 //Input(s) 13575 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13576 // int -> Dimensions map 13577 .operandDimensions = {{0, {1, 1, 1, 2}}}, 13578 // int -> FLOAT32 map 13579 .float32Operands = {}, 13580 // int -> INT32 map 13581 .int32Operands = {}, 13582 // int -> QUANT8_ASYMM map 13583 .quant8AsymmOperands = {{0, {150, 250}}}, 13584 // int -> QUANT16_SYMM map 13585 .quant16SymmOperands = {}, 13586 // int -> FLOAT16 map 13587 .float16Operands = {}, 13588 // int -> BOOL8 map 13589 .bool8Operands = {}, 13590 // int -> QUANT8_SYMM_PER_CHANNEL map 13591 .quant8ChannelOperands = {}, 13592 // int -> QUANT16_ASYMM map 13593 .quant16AsymmOperands = {}, 13594 // int -> QUANT8_SYMM map 13595 .quant8SymmOperands = {}, 13596 }, 13597 //Output(s) 13598 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13599 // int -> Dimensions map 13600 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13601 // int -> FLOAT32 map 13602 .float32Operands = {}, 13603 // int -> INT32 map 13604 .int32Operands = {}, 13605 // int -> QUANT8_ASYMM map 13606 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13607 // int -> QUANT16_SYMM map 13608 .quant16SymmOperands = {}, 13609 // int -> FLOAT16 map 13610 .float16Operands = {}, 13611 // int -> BOOL8 map 13612 .bool8Operands = {}, 13613 // int -> QUANT8_SYMM_PER_CHANNEL map 13614 .quant8ChannelOperands = {}, 13615 // int -> QUANT16_ASYMM map 13616 .quant16AsymmOperands = {}, 13617 // int -> QUANT8_SYMM map 13618 .quant8SymmOperands = {}, 13619 } 13620 }, 13621 }, // End of an example 13622 }; 13623 return examples_nchw_quant8; 13624 }; 13625 13626 std::vector<MixedTypedExample>& get_examples_nchw_quant8_weight_as_input() { 13627 static std::vector<MixedTypedExample> examples_nchw_quant8_weight_as_input = { 13628 // Begin of an example 13629 { 13630 .operands = { 13631 //Input(s) 13632 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13633 // int -> Dimensions map 13634 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13635 // int -> FLOAT32 map 13636 .float32Operands = {}, 13637 // int -> INT32 map 13638 .int32Operands = {{2, {-2000}}}, 13639 // int -> QUANT8_ASYMM map 13640 .quant8AsymmOperands = {{0, {150, 250}}, {1, {164, 148, 152, 164, 160, 148, 140, 132, 144}}}, 13641 // int -> QUANT16_SYMM map 13642 .quant16SymmOperands = {}, 13643 // int -> FLOAT16 map 13644 .float16Operands = {}, 13645 // int -> BOOL8 map 13646 .bool8Operands = {}, 13647 // int -> QUANT8_SYMM_PER_CHANNEL map 13648 .quant8ChannelOperands = {}, 13649 // int -> QUANT16_ASYMM map 13650 .quant16AsymmOperands = {}, 13651 // int -> QUANT8_SYMM map 13652 .quant8SymmOperands = {}, 13653 }, 13654 //Output(s) 13655 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13656 // int -> Dimensions map 13657 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13658 // int -> FLOAT32 map 13659 .float32Operands = {}, 13660 // int -> INT32 map 13661 .int32Operands = {}, 13662 // int -> QUANT8_ASYMM map 13663 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13664 // int -> QUANT16_SYMM map 13665 .quant16SymmOperands = {}, 13666 // int -> FLOAT16 map 13667 .float16Operands = {}, 13668 // int -> BOOL8 map 13669 .bool8Operands = {}, 13670 // int -> QUANT8_SYMM_PER_CHANNEL map 13671 .quant8ChannelOperands = {}, 13672 // int -> QUANT16_ASYMM map 13673 .quant16AsymmOperands = {}, 13674 // int -> QUANT8_SYMM map 13675 .quant8SymmOperands = {}, 13676 } 13677 }, 13678 }, // End of an example 13679 }; 13680 return examples_nchw_quant8_weight_as_input; 13681 }; 13682 13683 std::vector<MixedTypedExample>& get_examples_nchw_channelQuant8() { 13684 static std::vector<MixedTypedExample> examples_nchw_channelQuant8 = { 13685 // Begin of an example 13686 { 13687 .operands = { 13688 //Input(s) 13689 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13690 // int -> Dimensions map 13691 .operandDimensions = {{0, {1, 1, 1, 2}}}, 13692 // int -> FLOAT32 map 13693 .float32Operands = {}, 13694 // int -> INT32 map 13695 .int32Operands = {}, 13696 // int -> QUANT8_ASYMM map 13697 .quant8AsymmOperands = {{0, {150, 250}}}, 13698 // int -> QUANT16_SYMM map 13699 .quant16SymmOperands = {}, 13700 // int -> FLOAT16 map 13701 .float16Operands = {}, 13702 // int -> BOOL8 map 13703 .bool8Operands = {}, 13704 // int -> QUANT8_SYMM_PER_CHANNEL map 13705 .quant8ChannelOperands = {}, 13706 // int -> QUANT16_ASYMM map 13707 .quant16AsymmOperands = {}, 13708 // int -> QUANT8_SYMM map 13709 .quant8SymmOperands = {}, 13710 }, 13711 //Output(s) 13712 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13713 // int -> Dimensions map 13714 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13715 // int -> FLOAT32 map 13716 .float32Operands = {}, 13717 // int -> INT32 map 13718 .int32Operands = {}, 13719 // int -> QUANT8_ASYMM map 13720 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13721 // int -> QUANT16_SYMM map 13722 .quant16SymmOperands = {}, 13723 // int -> FLOAT16 map 13724 .float16Operands = {}, 13725 // int -> BOOL8 map 13726 .bool8Operands = {}, 13727 // int -> QUANT8_SYMM_PER_CHANNEL map 13728 .quant8ChannelOperands = {}, 13729 // int -> QUANT16_ASYMM map 13730 .quant16AsymmOperands = {}, 13731 // int -> QUANT8_SYMM map 13732 .quant8SymmOperands = {}, 13733 } 13734 }, 13735 }, // End of an example 13736 }; 13737 return examples_nchw_channelQuant8; 13738 }; 13739 13740 std::vector<MixedTypedExample>& get_examples_nchw_channelQuant8_weight_as_input() { 13741 static std::vector<MixedTypedExample> examples_nchw_channelQuant8_weight_as_input = { 13742 // Begin of an example 13743 { 13744 .operands = { 13745 //Input(s) 13746 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13747 // int -> Dimensions map 13748 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13749 // int -> FLOAT32 map 13750 .float32Operands = {}, 13751 // int -> INT32 map 13752 .int32Operands = {{2, {-2000}}}, 13753 // int -> QUANT8_ASYMM map 13754 .quant8AsymmOperands = {{0, {150, 250}}}, 13755 // int -> QUANT16_SYMM map 13756 .quant16SymmOperands = {}, 13757 // int -> FLOAT16 map 13758 .float16Operands = {}, 13759 // int -> BOOL8 map 13760 .bool8Operands = {}, 13761 // int -> QUANT8_SYMM_PER_CHANNEL map 13762 .quant8ChannelOperands = {{1, {36, 20, 24, 36, 32, 20, 12, 4, 16}}}, 13763 // int -> QUANT16_ASYMM map 13764 .quant16AsymmOperands = {}, 13765 // int -> QUANT8_SYMM map 13766 .quant8SymmOperands = {}, 13767 }, 13768 //Output(s) 13769 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13770 // int -> Dimensions map 13771 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13772 // int -> FLOAT32 map 13773 .float32Operands = {}, 13774 // int -> INT32 map 13775 .int32Operands = {}, 13776 // int -> QUANT8_ASYMM map 13777 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 13778 // int -> QUANT16_SYMM map 13779 .quant16SymmOperands = {}, 13780 // int -> FLOAT16 map 13781 .float16Operands = {}, 13782 // int -> BOOL8 map 13783 .bool8Operands = {}, 13784 // int -> QUANT8_SYMM_PER_CHANNEL map 13785 .quant8ChannelOperands = {}, 13786 // int -> QUANT16_ASYMM map 13787 .quant16AsymmOperands = {}, 13788 // int -> QUANT8_SYMM map 13789 .quant8SymmOperands = {}, 13790 } 13791 }, 13792 }, // End of an example 13793 }; 13794 return examples_nchw_channelQuant8_weight_as_input; 13795 }; 13796 13797 std::vector<MixedTypedExample>& get_examples_nchw_float16() { 13798 static std::vector<MixedTypedExample> examples_nchw_float16 = { 13799 // Begin of an example 13800 { 13801 .operands = { 13802 //Input(s) 13803 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13804 // int -> Dimensions map 13805 .operandDimensions = {{0, {1, 1, 1, 2}}}, 13806 // int -> FLOAT32 map 13807 .float32Operands = {}, 13808 // int -> INT32 map 13809 .int32Operands = {}, 13810 // int -> QUANT8_ASYMM map 13811 .quant8AsymmOperands = {}, 13812 // int -> QUANT16_SYMM map 13813 .quant16SymmOperands = {}, 13814 // int -> FLOAT16 map 13815 .float16Operands = {{0, {300.0f, 500.0f}}}, 13816 // int -> BOOL8 map 13817 .bool8Operands = {}, 13818 // int -> QUANT8_SYMM_PER_CHANNEL map 13819 .quant8ChannelOperands = {}, 13820 // int -> QUANT16_ASYMM map 13821 .quant16AsymmOperands = {}, 13822 // int -> QUANT8_SYMM map 13823 .quant8SymmOperands = {}, 13824 }, 13825 //Output(s) 13826 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13827 // int -> Dimensions map 13828 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13829 // int -> FLOAT32 map 13830 .float32Operands = {}, 13831 // int -> INT32 map 13832 .int32Operands = {}, 13833 // int -> QUANT8_ASYMM map 13834 .quant8AsymmOperands = {}, 13835 // int -> QUANT16_SYMM map 13836 .quant16SymmOperands = {}, 13837 // int -> FLOAT16 map 13838 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13839 // int -> BOOL8 map 13840 .bool8Operands = {}, 13841 // int -> QUANT8_SYMM_PER_CHANNEL map 13842 .quant8ChannelOperands = {}, 13843 // int -> QUANT16_ASYMM map 13844 .quant16AsymmOperands = {}, 13845 // int -> QUANT8_SYMM map 13846 .quant8SymmOperands = {}, 13847 } 13848 }, 13849 }, // End of an example 13850 }; 13851 return examples_nchw_float16; 13852 }; 13853 13854 std::vector<MixedTypedExample>& get_examples_nchw_float16_weight_as_input() { 13855 static std::vector<MixedTypedExample> examples_nchw_float16_weight_as_input = { 13856 // Begin of an example 13857 { 13858 .operands = { 13859 //Input(s) 13860 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13861 // int -> Dimensions map 13862 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13863 // int -> FLOAT32 map 13864 .float32Operands = {}, 13865 // int -> INT32 map 13866 .int32Operands = {}, 13867 // int -> QUANT8_ASYMM map 13868 .quant8AsymmOperands = {}, 13869 // int -> QUANT16_SYMM map 13870 .quant16SymmOperands = {}, 13871 // int -> FLOAT16 map 13872 .float16Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 13873 // int -> BOOL8 map 13874 .bool8Operands = {}, 13875 // int -> QUANT8_SYMM_PER_CHANNEL map 13876 .quant8ChannelOperands = {}, 13877 // int -> QUANT16_ASYMM map 13878 .quant16AsymmOperands = {}, 13879 // int -> QUANT8_SYMM map 13880 .quant8SymmOperands = {}, 13881 }, 13882 //Output(s) 13883 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13884 // int -> Dimensions map 13885 .operandDimensions = {{0, {1, 1, 3, 4}}}, 13886 // int -> FLOAT32 map 13887 .float32Operands = {}, 13888 // int -> INT32 map 13889 .int32Operands = {}, 13890 // int -> QUANT8_ASYMM map 13891 .quant8AsymmOperands = {}, 13892 // int -> QUANT16_SYMM map 13893 .quant16SymmOperands = {}, 13894 // int -> FLOAT16 map 13895 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13896 // int -> BOOL8 map 13897 .bool8Operands = {}, 13898 // int -> QUANT8_SYMM_PER_CHANNEL map 13899 .quant8ChannelOperands = {}, 13900 // int -> QUANT16_ASYMM map 13901 .quant16AsymmOperands = {}, 13902 // int -> QUANT8_SYMM map 13903 .quant8SymmOperands = {}, 13904 } 13905 }, 13906 }, // End of an example 13907 }; 13908 return examples_nchw_float16_weight_as_input; 13909 }; 13910 13911 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc() { 13912 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc = { 13913 // Begin of an example 13914 { 13915 .operands = { 13916 //Input(s) 13917 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13918 // int -> Dimensions map 13919 .operandDimensions = {{0, {1, 1, 2, 1}}}, 13920 // int -> FLOAT32 map 13921 .float32Operands = {{0, {300.0f, 500.0f}}}, 13922 // int -> INT32 map 13923 .int32Operands = {}, 13924 // int -> QUANT8_ASYMM map 13925 .quant8AsymmOperands = {}, 13926 // int -> QUANT16_SYMM map 13927 .quant16SymmOperands = {}, 13928 // int -> FLOAT16 map 13929 .float16Operands = {}, 13930 // int -> BOOL8 map 13931 .bool8Operands = {}, 13932 // int -> QUANT8_SYMM_PER_CHANNEL map 13933 .quant8ChannelOperands = {}, 13934 // int -> QUANT16_ASYMM map 13935 .quant16AsymmOperands = {}, 13936 // int -> QUANT8_SYMM map 13937 .quant8SymmOperands = {}, 13938 }, 13939 //Output(s) 13940 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13941 // int -> Dimensions map 13942 .operandDimensions = {{0, {1, 3, 4, 1}}}, 13943 // int -> FLOAT32 map 13944 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 13945 // int -> INT32 map 13946 .int32Operands = {}, 13947 // int -> QUANT8_ASYMM map 13948 .quant8AsymmOperands = {}, 13949 // int -> QUANT16_SYMM map 13950 .quant16SymmOperands = {}, 13951 // int -> FLOAT16 map 13952 .float16Operands = {}, 13953 // int -> BOOL8 map 13954 .bool8Operands = {}, 13955 // int -> QUANT8_SYMM_PER_CHANNEL map 13956 .quant8ChannelOperands = {}, 13957 // int -> QUANT16_ASYMM map 13958 .quant16AsymmOperands = {}, 13959 // int -> QUANT8_SYMM map 13960 .quant8SymmOperands = {}, 13961 } 13962 }, 13963 }, // End of an example 13964 }; 13965 return examples_dynamic_output_shape_nhwc; 13966 }; 13967 13968 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input() { 13969 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input = { 13970 // Begin of an example 13971 { 13972 .operands = { 13973 //Input(s) 13974 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13975 // int -> Dimensions map 13976 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 13977 // int -> FLOAT32 map 13978 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 13979 // int -> INT32 map 13980 .int32Operands = {}, 13981 // int -> QUANT8_ASYMM map 13982 .quant8AsymmOperands = {}, 13983 // int -> QUANT16_SYMM map 13984 .quant16SymmOperands = {}, 13985 // int -> FLOAT16 map 13986 .float16Operands = {}, 13987 // int -> BOOL8 map 13988 .bool8Operands = {}, 13989 // int -> QUANT8_SYMM_PER_CHANNEL map 13990 .quant8ChannelOperands = {}, 13991 // int -> QUANT16_ASYMM map 13992 .quant16AsymmOperands = {}, 13993 // int -> QUANT8_SYMM map 13994 .quant8SymmOperands = {}, 13995 }, 13996 //Output(s) 13997 { // See tools/test_generator/include/TestHarness.h:MixedTyped 13998 // int -> Dimensions map 13999 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14000 // int -> FLOAT32 map 14001 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14002 // int -> INT32 map 14003 .int32Operands = {}, 14004 // int -> QUANT8_ASYMM map 14005 .quant8AsymmOperands = {}, 14006 // int -> QUANT16_SYMM map 14007 .quant16SymmOperands = {}, 14008 // int -> FLOAT16 map 14009 .float16Operands = {}, 14010 // int -> BOOL8 map 14011 .bool8Operands = {}, 14012 // int -> QUANT8_SYMM_PER_CHANNEL map 14013 .quant8ChannelOperands = {}, 14014 // int -> QUANT16_ASYMM map 14015 .quant16AsymmOperands = {}, 14016 // int -> QUANT8_SYMM map 14017 .quant8SymmOperands = {}, 14018 } 14019 }, 14020 }, // End of an example 14021 }; 14022 return examples_dynamic_output_shape_nhwc_weight_as_input; 14023 }; 14024 14025 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed() { 14026 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed = { 14027 // Begin of an example 14028 { 14029 .operands = { 14030 //Input(s) 14031 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14032 // int -> Dimensions map 14033 .operandDimensions = {{0, {1, 1, 2, 1}}}, 14034 // int -> FLOAT32 map 14035 .float32Operands = {{0, {300.0f, 500.0f}}}, 14036 // int -> INT32 map 14037 .int32Operands = {}, 14038 // int -> QUANT8_ASYMM map 14039 .quant8AsymmOperands = {}, 14040 // int -> QUANT16_SYMM map 14041 .quant16SymmOperands = {}, 14042 // int -> FLOAT16 map 14043 .float16Operands = {}, 14044 // int -> BOOL8 map 14045 .bool8Operands = {}, 14046 // int -> QUANT8_SYMM_PER_CHANNEL map 14047 .quant8ChannelOperands = {}, 14048 // int -> QUANT16_ASYMM map 14049 .quant16AsymmOperands = {}, 14050 // int -> QUANT8_SYMM map 14051 .quant8SymmOperands = {}, 14052 }, 14053 //Output(s) 14054 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14055 // int -> Dimensions map 14056 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14057 // int -> FLOAT32 map 14058 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14059 // int -> INT32 map 14060 .int32Operands = {}, 14061 // int -> QUANT8_ASYMM map 14062 .quant8AsymmOperands = {}, 14063 // int -> QUANT16_SYMM map 14064 .quant16SymmOperands = {}, 14065 // int -> FLOAT16 map 14066 .float16Operands = {}, 14067 // int -> BOOL8 map 14068 .bool8Operands = {}, 14069 // int -> QUANT8_SYMM_PER_CHANNEL map 14070 .quant8ChannelOperands = {}, 14071 // int -> QUANT16_ASYMM map 14072 .quant16AsymmOperands = {}, 14073 // int -> QUANT8_SYMM map 14074 .quant8SymmOperands = {}, 14075 } 14076 }, 14077 }, // End of an example 14078 }; 14079 return examples_dynamic_output_shape_nhwc_relaxed; 14080 }; 14081 14082 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_weight_as_input() { 14083 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_weight_as_input = { 14084 // Begin of an example 14085 { 14086 .operands = { 14087 //Input(s) 14088 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14089 // int -> Dimensions map 14090 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14091 // int -> FLOAT32 map 14092 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 14093 // int -> INT32 map 14094 .int32Operands = {}, 14095 // int -> QUANT8_ASYMM map 14096 .quant8AsymmOperands = {}, 14097 // int -> QUANT16_SYMM map 14098 .quant16SymmOperands = {}, 14099 // int -> FLOAT16 map 14100 .float16Operands = {}, 14101 // int -> BOOL8 map 14102 .bool8Operands = {}, 14103 // int -> QUANT8_SYMM_PER_CHANNEL map 14104 .quant8ChannelOperands = {}, 14105 // int -> QUANT16_ASYMM map 14106 .quant16AsymmOperands = {}, 14107 // int -> QUANT8_SYMM map 14108 .quant8SymmOperands = {}, 14109 }, 14110 //Output(s) 14111 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14112 // int -> Dimensions map 14113 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14114 // int -> FLOAT32 map 14115 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14116 // int -> INT32 map 14117 .int32Operands = {}, 14118 // int -> QUANT8_ASYMM map 14119 .quant8AsymmOperands = {}, 14120 // int -> QUANT16_SYMM map 14121 .quant16SymmOperands = {}, 14122 // int -> FLOAT16 map 14123 .float16Operands = {}, 14124 // int -> BOOL8 map 14125 .bool8Operands = {}, 14126 // int -> QUANT8_SYMM_PER_CHANNEL map 14127 .quant8ChannelOperands = {}, 14128 // int -> QUANT16_ASYMM map 14129 .quant16AsymmOperands = {}, 14130 // int -> QUANT8_SYMM map 14131 .quant8SymmOperands = {}, 14132 } 14133 }, 14134 }, // End of an example 14135 }; 14136 return examples_dynamic_output_shape_nhwc_relaxed_weight_as_input; 14137 }; 14138 14139 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8() { 14140 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8 = { 14141 // Begin of an example 14142 { 14143 .operands = { 14144 //Input(s) 14145 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14146 // int -> Dimensions map 14147 .operandDimensions = {{0, {1, 1, 2, 1}}}, 14148 // int -> FLOAT32 map 14149 .float32Operands = {}, 14150 // int -> INT32 map 14151 .int32Operands = {}, 14152 // int -> QUANT8_ASYMM map 14153 .quant8AsymmOperands = {{0, {150, 250}}}, 14154 // int -> QUANT16_SYMM map 14155 .quant16SymmOperands = {}, 14156 // int -> FLOAT16 map 14157 .float16Operands = {}, 14158 // int -> BOOL8 map 14159 .bool8Operands = {}, 14160 // int -> QUANT8_SYMM_PER_CHANNEL map 14161 .quant8ChannelOperands = {}, 14162 // int -> QUANT16_ASYMM map 14163 .quant16AsymmOperands = {}, 14164 // int -> QUANT8_SYMM map 14165 .quant8SymmOperands = {}, 14166 }, 14167 //Output(s) 14168 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14169 // int -> Dimensions map 14170 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14171 // int -> FLOAT32 map 14172 .float32Operands = {}, 14173 // int -> INT32 map 14174 .int32Operands = {}, 14175 // int -> QUANT8_ASYMM map 14176 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14177 // int -> QUANT16_SYMM map 14178 .quant16SymmOperands = {}, 14179 // int -> FLOAT16 map 14180 .float16Operands = {}, 14181 // int -> BOOL8 map 14182 .bool8Operands = {}, 14183 // int -> QUANT8_SYMM_PER_CHANNEL map 14184 .quant8ChannelOperands = {}, 14185 // int -> QUANT16_ASYMM map 14186 .quant16AsymmOperands = {}, 14187 // int -> QUANT8_SYMM map 14188 .quant8SymmOperands = {}, 14189 } 14190 }, 14191 }, // End of an example 14192 }; 14193 return examples_dynamic_output_shape_nhwc_quant8; 14194 }; 14195 14196 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_weight_as_input() { 14197 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_weight_as_input = { 14198 // Begin of an example 14199 { 14200 .operands = { 14201 //Input(s) 14202 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14203 // int -> Dimensions map 14204 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14205 // int -> FLOAT32 map 14206 .float32Operands = {}, 14207 // int -> INT32 map 14208 .int32Operands = {{2, {-2000}}}, 14209 // int -> QUANT8_ASYMM map 14210 .quant8AsymmOperands = {{0, {150, 250}}, {1, {164, 148, 152, 164, 160, 148, 140, 132, 144}}}, 14211 // int -> QUANT16_SYMM map 14212 .quant16SymmOperands = {}, 14213 // int -> FLOAT16 map 14214 .float16Operands = {}, 14215 // int -> BOOL8 map 14216 .bool8Operands = {}, 14217 // int -> QUANT8_SYMM_PER_CHANNEL map 14218 .quant8ChannelOperands = {}, 14219 // int -> QUANT16_ASYMM map 14220 .quant16AsymmOperands = {}, 14221 // int -> QUANT8_SYMM map 14222 .quant8SymmOperands = {}, 14223 }, 14224 //Output(s) 14225 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14226 // int -> Dimensions map 14227 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14228 // int -> FLOAT32 map 14229 .float32Operands = {}, 14230 // int -> INT32 map 14231 .int32Operands = {}, 14232 // int -> QUANT8_ASYMM map 14233 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14234 // int -> QUANT16_SYMM map 14235 .quant16SymmOperands = {}, 14236 // int -> FLOAT16 map 14237 .float16Operands = {}, 14238 // int -> BOOL8 map 14239 .bool8Operands = {}, 14240 // int -> QUANT8_SYMM_PER_CHANNEL map 14241 .quant8ChannelOperands = {}, 14242 // int -> QUANT16_ASYMM map 14243 .quant16AsymmOperands = {}, 14244 // int -> QUANT8_SYMM map 14245 .quant8SymmOperands = {}, 14246 } 14247 }, 14248 }, // End of an example 14249 }; 14250 return examples_dynamic_output_shape_nhwc_quant8_weight_as_input; 14251 }; 14252 14253 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_channelQuant8() { 14254 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_channelQuant8 = { 14255 // Begin of an example 14256 { 14257 .operands = { 14258 //Input(s) 14259 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14260 // int -> Dimensions map 14261 .operandDimensions = {{0, {1, 1, 2, 1}}}, 14262 // int -> FLOAT32 map 14263 .float32Operands = {}, 14264 // int -> INT32 map 14265 .int32Operands = {}, 14266 // int -> QUANT8_ASYMM map 14267 .quant8AsymmOperands = {{0, {150, 250}}}, 14268 // int -> QUANT16_SYMM map 14269 .quant16SymmOperands = {}, 14270 // int -> FLOAT16 map 14271 .float16Operands = {}, 14272 // int -> BOOL8 map 14273 .bool8Operands = {}, 14274 // int -> QUANT8_SYMM_PER_CHANNEL map 14275 .quant8ChannelOperands = {}, 14276 // int -> QUANT16_ASYMM map 14277 .quant16AsymmOperands = {}, 14278 // int -> QUANT8_SYMM map 14279 .quant8SymmOperands = {}, 14280 }, 14281 //Output(s) 14282 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14283 // int -> Dimensions map 14284 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14285 // int -> FLOAT32 map 14286 .float32Operands = {}, 14287 // int -> INT32 map 14288 .int32Operands = {}, 14289 // int -> QUANT8_ASYMM map 14290 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14291 // int -> QUANT16_SYMM map 14292 .quant16SymmOperands = {}, 14293 // int -> FLOAT16 map 14294 .float16Operands = {}, 14295 // int -> BOOL8 map 14296 .bool8Operands = {}, 14297 // int -> QUANT8_SYMM_PER_CHANNEL map 14298 .quant8ChannelOperands = {}, 14299 // int -> QUANT16_ASYMM map 14300 .quant16AsymmOperands = {}, 14301 // int -> QUANT8_SYMM map 14302 .quant8SymmOperands = {}, 14303 } 14304 }, 14305 }, // End of an example 14306 }; 14307 return examples_dynamic_output_shape_nhwc_channelQuant8; 14308 }; 14309 14310 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_channelQuant8_weight_as_input() { 14311 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_channelQuant8_weight_as_input = { 14312 // Begin of an example 14313 { 14314 .operands = { 14315 //Input(s) 14316 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14317 // int -> Dimensions map 14318 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14319 // int -> FLOAT32 map 14320 .float32Operands = {}, 14321 // int -> INT32 map 14322 .int32Operands = {{2, {-2000}}}, 14323 // int -> QUANT8_ASYMM map 14324 .quant8AsymmOperands = {{0, {150, 250}}}, 14325 // int -> QUANT16_SYMM map 14326 .quant16SymmOperands = {}, 14327 // int -> FLOAT16 map 14328 .float16Operands = {}, 14329 // int -> BOOL8 map 14330 .bool8Operands = {}, 14331 // int -> QUANT8_SYMM_PER_CHANNEL map 14332 .quant8ChannelOperands = {{1, {36, 20, 24, 36, 32, 20, 12, 4, 16}}}, 14333 // int -> QUANT16_ASYMM map 14334 .quant16AsymmOperands = {}, 14335 // int -> QUANT8_SYMM map 14336 .quant8SymmOperands = {}, 14337 }, 14338 //Output(s) 14339 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14340 // int -> Dimensions map 14341 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14342 // int -> FLOAT32 map 14343 .float32Operands = {}, 14344 // int -> INT32 map 14345 .int32Operands = {}, 14346 // int -> QUANT8_ASYMM map 14347 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14348 // int -> QUANT16_SYMM map 14349 .quant16SymmOperands = {}, 14350 // int -> FLOAT16 map 14351 .float16Operands = {}, 14352 // int -> BOOL8 map 14353 .bool8Operands = {}, 14354 // int -> QUANT8_SYMM_PER_CHANNEL map 14355 .quant8ChannelOperands = {}, 14356 // int -> QUANT16_ASYMM map 14357 .quant16AsymmOperands = {}, 14358 // int -> QUANT8_SYMM map 14359 .quant8SymmOperands = {}, 14360 } 14361 }, 14362 }, // End of an example 14363 }; 14364 return examples_dynamic_output_shape_nhwc_channelQuant8_weight_as_input; 14365 }; 14366 14367 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16() { 14368 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16 = { 14369 // Begin of an example 14370 { 14371 .operands = { 14372 //Input(s) 14373 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14374 // int -> Dimensions map 14375 .operandDimensions = {{0, {1, 1, 2, 1}}}, 14376 // int -> FLOAT32 map 14377 .float32Operands = {}, 14378 // int -> INT32 map 14379 .int32Operands = {}, 14380 // int -> QUANT8_ASYMM map 14381 .quant8AsymmOperands = {}, 14382 // int -> QUANT16_SYMM map 14383 .quant16SymmOperands = {}, 14384 // int -> FLOAT16 map 14385 .float16Operands = {{0, {300.0f, 500.0f}}}, 14386 // int -> BOOL8 map 14387 .bool8Operands = {}, 14388 // int -> QUANT8_SYMM_PER_CHANNEL map 14389 .quant8ChannelOperands = {}, 14390 // int -> QUANT16_ASYMM map 14391 .quant16AsymmOperands = {}, 14392 // int -> QUANT8_SYMM map 14393 .quant8SymmOperands = {}, 14394 }, 14395 //Output(s) 14396 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14397 // int -> Dimensions map 14398 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14399 // int -> FLOAT32 map 14400 .float32Operands = {}, 14401 // int -> INT32 map 14402 .int32Operands = {}, 14403 // int -> QUANT8_ASYMM map 14404 .quant8AsymmOperands = {}, 14405 // int -> QUANT16_SYMM map 14406 .quant16SymmOperands = {}, 14407 // int -> FLOAT16 map 14408 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14409 // int -> BOOL8 map 14410 .bool8Operands = {}, 14411 // int -> QUANT8_SYMM_PER_CHANNEL map 14412 .quant8ChannelOperands = {}, 14413 // int -> QUANT16_ASYMM map 14414 .quant16AsymmOperands = {}, 14415 // int -> QUANT8_SYMM map 14416 .quant8SymmOperands = {}, 14417 } 14418 }, 14419 }, // End of an example 14420 }; 14421 return examples_dynamic_output_shape_nhwc_float16; 14422 }; 14423 14424 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_weight_as_input() { 14425 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_weight_as_input = { 14426 // Begin of an example 14427 { 14428 .operands = { 14429 //Input(s) 14430 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14431 // int -> Dimensions map 14432 .operandDimensions = {{0, {1, 1, 2, 1}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14433 // int -> FLOAT32 map 14434 .float32Operands = {}, 14435 // int -> INT32 map 14436 .int32Operands = {}, 14437 // int -> QUANT8_ASYMM map 14438 .quant8AsymmOperands = {}, 14439 // int -> QUANT16_SYMM map 14440 .quant16SymmOperands = {}, 14441 // int -> FLOAT16 map 14442 .float16Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 14443 // int -> BOOL8 map 14444 .bool8Operands = {}, 14445 // int -> QUANT8_SYMM_PER_CHANNEL map 14446 .quant8ChannelOperands = {}, 14447 // int -> QUANT16_ASYMM map 14448 .quant16AsymmOperands = {}, 14449 // int -> QUANT8_SYMM map 14450 .quant8SymmOperands = {}, 14451 }, 14452 //Output(s) 14453 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14454 // int -> Dimensions map 14455 .operandDimensions = {{0, {1, 3, 4, 1}}}, 14456 // int -> FLOAT32 map 14457 .float32Operands = {}, 14458 // int -> INT32 map 14459 .int32Operands = {}, 14460 // int -> QUANT8_ASYMM map 14461 .quant8AsymmOperands = {}, 14462 // int -> QUANT16_SYMM map 14463 .quant16SymmOperands = {}, 14464 // int -> FLOAT16 map 14465 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14466 // int -> BOOL8 map 14467 .bool8Operands = {}, 14468 // int -> QUANT8_SYMM_PER_CHANNEL map 14469 .quant8ChannelOperands = {}, 14470 // int -> QUANT16_ASYMM map 14471 .quant16AsymmOperands = {}, 14472 // int -> QUANT8_SYMM map 14473 .quant8SymmOperands = {}, 14474 } 14475 }, 14476 }, // End of an example 14477 }; 14478 return examples_dynamic_output_shape_nhwc_float16_weight_as_input; 14479 }; 14480 14481 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw() { 14482 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw = { 14483 // Begin of an example 14484 { 14485 .operands = { 14486 //Input(s) 14487 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14488 // int -> Dimensions map 14489 .operandDimensions = {{0, {1, 1, 1, 2}}}, 14490 // int -> FLOAT32 map 14491 .float32Operands = {{0, {300.0f, 500.0f}}}, 14492 // int -> INT32 map 14493 .int32Operands = {}, 14494 // int -> QUANT8_ASYMM map 14495 .quant8AsymmOperands = {}, 14496 // int -> QUANT16_SYMM map 14497 .quant16SymmOperands = {}, 14498 // int -> FLOAT16 map 14499 .float16Operands = {}, 14500 // int -> BOOL8 map 14501 .bool8Operands = {}, 14502 // int -> QUANT8_SYMM_PER_CHANNEL map 14503 .quant8ChannelOperands = {}, 14504 // int -> QUANT16_ASYMM map 14505 .quant16AsymmOperands = {}, 14506 // int -> QUANT8_SYMM map 14507 .quant8SymmOperands = {}, 14508 }, 14509 //Output(s) 14510 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14511 // int -> Dimensions map 14512 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14513 // int -> FLOAT32 map 14514 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14515 // int -> INT32 map 14516 .int32Operands = {}, 14517 // int -> QUANT8_ASYMM map 14518 .quant8AsymmOperands = {}, 14519 // int -> QUANT16_SYMM map 14520 .quant16SymmOperands = {}, 14521 // int -> FLOAT16 map 14522 .float16Operands = {}, 14523 // int -> BOOL8 map 14524 .bool8Operands = {}, 14525 // int -> QUANT8_SYMM_PER_CHANNEL map 14526 .quant8ChannelOperands = {}, 14527 // int -> QUANT16_ASYMM map 14528 .quant16AsymmOperands = {}, 14529 // int -> QUANT8_SYMM map 14530 .quant8SymmOperands = {}, 14531 } 14532 }, 14533 }, // End of an example 14534 }; 14535 return examples_dynamic_output_shape_nchw; 14536 }; 14537 14538 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input() { 14539 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input = { 14540 // Begin of an example 14541 { 14542 .operands = { 14543 //Input(s) 14544 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14545 // int -> Dimensions map 14546 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14547 // int -> FLOAT32 map 14548 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 14549 // int -> INT32 map 14550 .int32Operands = {}, 14551 // int -> QUANT8_ASYMM map 14552 .quant8AsymmOperands = {}, 14553 // int -> QUANT16_SYMM map 14554 .quant16SymmOperands = {}, 14555 // int -> FLOAT16 map 14556 .float16Operands = {}, 14557 // int -> BOOL8 map 14558 .bool8Operands = {}, 14559 // int -> QUANT8_SYMM_PER_CHANNEL map 14560 .quant8ChannelOperands = {}, 14561 // int -> QUANT16_ASYMM map 14562 .quant16AsymmOperands = {}, 14563 // int -> QUANT8_SYMM map 14564 .quant8SymmOperands = {}, 14565 }, 14566 //Output(s) 14567 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14568 // int -> Dimensions map 14569 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14570 // int -> FLOAT32 map 14571 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14572 // int -> INT32 map 14573 .int32Operands = {}, 14574 // int -> QUANT8_ASYMM map 14575 .quant8AsymmOperands = {}, 14576 // int -> QUANT16_SYMM map 14577 .quant16SymmOperands = {}, 14578 // int -> FLOAT16 map 14579 .float16Operands = {}, 14580 // int -> BOOL8 map 14581 .bool8Operands = {}, 14582 // int -> QUANT8_SYMM_PER_CHANNEL map 14583 .quant8ChannelOperands = {}, 14584 // int -> QUANT16_ASYMM map 14585 .quant16AsymmOperands = {}, 14586 // int -> QUANT8_SYMM map 14587 .quant8SymmOperands = {}, 14588 } 14589 }, 14590 }, // End of an example 14591 }; 14592 return examples_dynamic_output_shape_nchw_weight_as_input; 14593 }; 14594 14595 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed() { 14596 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed = { 14597 // Begin of an example 14598 { 14599 .operands = { 14600 //Input(s) 14601 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14602 // int -> Dimensions map 14603 .operandDimensions = {{0, {1, 1, 1, 2}}}, 14604 // int -> FLOAT32 map 14605 .float32Operands = {{0, {300.0f, 500.0f}}}, 14606 // int -> INT32 map 14607 .int32Operands = {}, 14608 // int -> QUANT8_ASYMM map 14609 .quant8AsymmOperands = {}, 14610 // int -> QUANT16_SYMM map 14611 .quant16SymmOperands = {}, 14612 // int -> FLOAT16 map 14613 .float16Operands = {}, 14614 // int -> BOOL8 map 14615 .bool8Operands = {}, 14616 // int -> QUANT8_SYMM_PER_CHANNEL map 14617 .quant8ChannelOperands = {}, 14618 // int -> QUANT16_ASYMM map 14619 .quant16AsymmOperands = {}, 14620 // int -> QUANT8_SYMM map 14621 .quant8SymmOperands = {}, 14622 }, 14623 //Output(s) 14624 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14625 // int -> Dimensions map 14626 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14627 // int -> FLOAT32 map 14628 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14629 // int -> INT32 map 14630 .int32Operands = {}, 14631 // int -> QUANT8_ASYMM map 14632 .quant8AsymmOperands = {}, 14633 // int -> QUANT16_SYMM map 14634 .quant16SymmOperands = {}, 14635 // int -> FLOAT16 map 14636 .float16Operands = {}, 14637 // int -> BOOL8 map 14638 .bool8Operands = {}, 14639 // int -> QUANT8_SYMM_PER_CHANNEL map 14640 .quant8ChannelOperands = {}, 14641 // int -> QUANT16_ASYMM map 14642 .quant16AsymmOperands = {}, 14643 // int -> QUANT8_SYMM map 14644 .quant8SymmOperands = {}, 14645 } 14646 }, 14647 }, // End of an example 14648 }; 14649 return examples_dynamic_output_shape_nchw_relaxed; 14650 }; 14651 14652 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_weight_as_input() { 14653 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_weight_as_input = { 14654 // Begin of an example 14655 { 14656 .operands = { 14657 //Input(s) 14658 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14659 // int -> Dimensions map 14660 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14661 // int -> FLOAT32 map 14662 .float32Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 14663 // int -> INT32 map 14664 .int32Operands = {}, 14665 // int -> QUANT8_ASYMM map 14666 .quant8AsymmOperands = {}, 14667 // int -> QUANT16_SYMM map 14668 .quant16SymmOperands = {}, 14669 // int -> FLOAT16 map 14670 .float16Operands = {}, 14671 // int -> BOOL8 map 14672 .bool8Operands = {}, 14673 // int -> QUANT8_SYMM_PER_CHANNEL map 14674 .quant8ChannelOperands = {}, 14675 // int -> QUANT16_ASYMM map 14676 .quant16AsymmOperands = {}, 14677 // int -> QUANT8_SYMM map 14678 .quant8SymmOperands = {}, 14679 }, 14680 //Output(s) 14681 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14682 // int -> Dimensions map 14683 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14684 // int -> FLOAT32 map 14685 .float32Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14686 // int -> INT32 map 14687 .int32Operands = {}, 14688 // int -> QUANT8_ASYMM map 14689 .quant8AsymmOperands = {}, 14690 // int -> QUANT16_SYMM map 14691 .quant16SymmOperands = {}, 14692 // int -> FLOAT16 map 14693 .float16Operands = {}, 14694 // int -> BOOL8 map 14695 .bool8Operands = {}, 14696 // int -> QUANT8_SYMM_PER_CHANNEL map 14697 .quant8ChannelOperands = {}, 14698 // int -> QUANT16_ASYMM map 14699 .quant16AsymmOperands = {}, 14700 // int -> QUANT8_SYMM map 14701 .quant8SymmOperands = {}, 14702 } 14703 }, 14704 }, // End of an example 14705 }; 14706 return examples_dynamic_output_shape_nchw_relaxed_weight_as_input; 14707 }; 14708 14709 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8() { 14710 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8 = { 14711 // Begin of an example 14712 { 14713 .operands = { 14714 //Input(s) 14715 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14716 // int -> Dimensions map 14717 .operandDimensions = {{0, {1, 1, 1, 2}}}, 14718 // int -> FLOAT32 map 14719 .float32Operands = {}, 14720 // int -> INT32 map 14721 .int32Operands = {}, 14722 // int -> QUANT8_ASYMM map 14723 .quant8AsymmOperands = {{0, {150, 250}}}, 14724 // int -> QUANT16_SYMM map 14725 .quant16SymmOperands = {}, 14726 // int -> FLOAT16 map 14727 .float16Operands = {}, 14728 // int -> BOOL8 map 14729 .bool8Operands = {}, 14730 // int -> QUANT8_SYMM_PER_CHANNEL map 14731 .quant8ChannelOperands = {}, 14732 // int -> QUANT16_ASYMM map 14733 .quant16AsymmOperands = {}, 14734 // int -> QUANT8_SYMM map 14735 .quant8SymmOperands = {}, 14736 }, 14737 //Output(s) 14738 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14739 // int -> Dimensions map 14740 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14741 // int -> FLOAT32 map 14742 .float32Operands = {}, 14743 // int -> INT32 map 14744 .int32Operands = {}, 14745 // int -> QUANT8_ASYMM map 14746 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14747 // int -> QUANT16_SYMM map 14748 .quant16SymmOperands = {}, 14749 // int -> FLOAT16 map 14750 .float16Operands = {}, 14751 // int -> BOOL8 map 14752 .bool8Operands = {}, 14753 // int -> QUANT8_SYMM_PER_CHANNEL map 14754 .quant8ChannelOperands = {}, 14755 // int -> QUANT16_ASYMM map 14756 .quant16AsymmOperands = {}, 14757 // int -> QUANT8_SYMM map 14758 .quant8SymmOperands = {}, 14759 } 14760 }, 14761 }, // End of an example 14762 }; 14763 return examples_dynamic_output_shape_nchw_quant8; 14764 }; 14765 14766 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_weight_as_input() { 14767 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_weight_as_input = { 14768 // Begin of an example 14769 { 14770 .operands = { 14771 //Input(s) 14772 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14773 // int -> Dimensions map 14774 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14775 // int -> FLOAT32 map 14776 .float32Operands = {}, 14777 // int -> INT32 map 14778 .int32Operands = {{2, {-2000}}}, 14779 // int -> QUANT8_ASYMM map 14780 .quant8AsymmOperands = {{0, {150, 250}}, {1, {164, 148, 152, 164, 160, 148, 140, 132, 144}}}, 14781 // int -> QUANT16_SYMM map 14782 .quant16SymmOperands = {}, 14783 // int -> FLOAT16 map 14784 .float16Operands = {}, 14785 // int -> BOOL8 map 14786 .bool8Operands = {}, 14787 // int -> QUANT8_SYMM_PER_CHANNEL map 14788 .quant8ChannelOperands = {}, 14789 // int -> QUANT16_ASYMM map 14790 .quant16AsymmOperands = {}, 14791 // int -> QUANT8_SYMM map 14792 .quant8SymmOperands = {}, 14793 }, 14794 //Output(s) 14795 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14796 // int -> Dimensions map 14797 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14798 // int -> FLOAT32 map 14799 .float32Operands = {}, 14800 // int -> INT32 map 14801 .int32Operands = {}, 14802 // int -> QUANT8_ASYMM map 14803 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14804 // int -> QUANT16_SYMM map 14805 .quant16SymmOperands = {}, 14806 // int -> FLOAT16 map 14807 .float16Operands = {}, 14808 // int -> BOOL8 map 14809 .bool8Operands = {}, 14810 // int -> QUANT8_SYMM_PER_CHANNEL map 14811 .quant8ChannelOperands = {}, 14812 // int -> QUANT16_ASYMM map 14813 .quant16AsymmOperands = {}, 14814 // int -> QUANT8_SYMM map 14815 .quant8SymmOperands = {}, 14816 } 14817 }, 14818 }, // End of an example 14819 }; 14820 return examples_dynamic_output_shape_nchw_quant8_weight_as_input; 14821 }; 14822 14823 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_channelQuant8() { 14824 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_channelQuant8 = { 14825 // Begin of an example 14826 { 14827 .operands = { 14828 //Input(s) 14829 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14830 // int -> Dimensions map 14831 .operandDimensions = {{0, {1, 1, 1, 2}}}, 14832 // int -> FLOAT32 map 14833 .float32Operands = {}, 14834 // int -> INT32 map 14835 .int32Operands = {}, 14836 // int -> QUANT8_ASYMM map 14837 .quant8AsymmOperands = {{0, {150, 250}}}, 14838 // int -> QUANT16_SYMM map 14839 .quant16SymmOperands = {}, 14840 // int -> FLOAT16 map 14841 .float16Operands = {}, 14842 // int -> BOOL8 map 14843 .bool8Operands = {}, 14844 // int -> QUANT8_SYMM_PER_CHANNEL map 14845 .quant8ChannelOperands = {}, 14846 // int -> QUANT16_ASYMM map 14847 .quant16AsymmOperands = {}, 14848 // int -> QUANT8_SYMM map 14849 .quant8SymmOperands = {}, 14850 }, 14851 //Output(s) 14852 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14853 // int -> Dimensions map 14854 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14855 // int -> FLOAT32 map 14856 .float32Operands = {}, 14857 // int -> INT32 map 14858 .int32Operands = {}, 14859 // int -> QUANT8_ASYMM map 14860 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14861 // int -> QUANT16_SYMM map 14862 .quant16SymmOperands = {}, 14863 // int -> FLOAT16 map 14864 .float16Operands = {}, 14865 // int -> BOOL8 map 14866 .bool8Operands = {}, 14867 // int -> QUANT8_SYMM_PER_CHANNEL map 14868 .quant8ChannelOperands = {}, 14869 // int -> QUANT16_ASYMM map 14870 .quant16AsymmOperands = {}, 14871 // int -> QUANT8_SYMM map 14872 .quant8SymmOperands = {}, 14873 } 14874 }, 14875 }, // End of an example 14876 }; 14877 return examples_dynamic_output_shape_nchw_channelQuant8; 14878 }; 14879 14880 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_channelQuant8_weight_as_input() { 14881 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_channelQuant8_weight_as_input = { 14882 // Begin of an example 14883 { 14884 .operands = { 14885 //Input(s) 14886 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14887 // int -> Dimensions map 14888 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 14889 // int -> FLOAT32 map 14890 .float32Operands = {}, 14891 // int -> INT32 map 14892 .int32Operands = {{2, {-2000}}}, 14893 // int -> QUANT8_ASYMM map 14894 .quant8AsymmOperands = {{0, {150, 250}}}, 14895 // int -> QUANT16_SYMM map 14896 .quant16SymmOperands = {}, 14897 // int -> FLOAT16 map 14898 .float16Operands = {}, 14899 // int -> BOOL8 map 14900 .bool8Operands = {}, 14901 // int -> QUANT8_SYMM_PER_CHANNEL map 14902 .quant8ChannelOperands = {{1, {36, 20, 24, 36, 32, 20, 12, 4, 16}}}, 14903 // int -> QUANT16_ASYMM map 14904 .quant16AsymmOperands = {}, 14905 // int -> QUANT8_SYMM map 14906 .quant8SymmOperands = {}, 14907 }, 14908 //Output(s) 14909 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14910 // int -> Dimensions map 14911 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14912 // int -> FLOAT32 map 14913 .float32Operands = {}, 14914 // int -> INT32 map 14915 .int32Operands = {}, 14916 // int -> QUANT8_ASYMM map 14917 .quant8AsymmOperands = {{0, {75, 90, 225, 125, 120, 75, 225, 200, 50, 60, 75, 50}}}, 14918 // int -> QUANT16_SYMM map 14919 .quant16SymmOperands = {}, 14920 // int -> FLOAT16 map 14921 .float16Operands = {}, 14922 // int -> BOOL8 map 14923 .bool8Operands = {}, 14924 // int -> QUANT8_SYMM_PER_CHANNEL map 14925 .quant8ChannelOperands = {}, 14926 // int -> QUANT16_ASYMM map 14927 .quant16AsymmOperands = {}, 14928 // int -> QUANT8_SYMM map 14929 .quant8SymmOperands = {}, 14930 } 14931 }, 14932 }, // End of an example 14933 }; 14934 return examples_dynamic_output_shape_nchw_channelQuant8_weight_as_input; 14935 }; 14936 14937 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16() { 14938 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16 = { 14939 // Begin of an example 14940 { 14941 .operands = { 14942 //Input(s) 14943 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14944 // int -> Dimensions map 14945 .operandDimensions = {{0, {1, 1, 1, 2}}}, 14946 // int -> FLOAT32 map 14947 .float32Operands = {}, 14948 // int -> INT32 map 14949 .int32Operands = {}, 14950 // int -> QUANT8_ASYMM map 14951 .quant8AsymmOperands = {}, 14952 // int -> QUANT16_SYMM map 14953 .quant16SymmOperands = {}, 14954 // int -> FLOAT16 map 14955 .float16Operands = {{0, {300.0f, 500.0f}}}, 14956 // int -> BOOL8 map 14957 .bool8Operands = {}, 14958 // int -> QUANT8_SYMM_PER_CHANNEL map 14959 .quant8ChannelOperands = {}, 14960 // int -> QUANT16_ASYMM map 14961 .quant16AsymmOperands = {}, 14962 // int -> QUANT8_SYMM map 14963 .quant8SymmOperands = {}, 14964 }, 14965 //Output(s) 14966 { // See tools/test_generator/include/TestHarness.h:MixedTyped 14967 // int -> Dimensions map 14968 .operandDimensions = {{0, {1, 1, 3, 4}}}, 14969 // int -> FLOAT32 map 14970 .float32Operands = {}, 14971 // int -> INT32 map 14972 .int32Operands = {}, 14973 // int -> QUANT8_ASYMM map 14974 .quant8AsymmOperands = {}, 14975 // int -> QUANT16_SYMM map 14976 .quant16SymmOperands = {}, 14977 // int -> FLOAT16 map 14978 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 14979 // int -> BOOL8 map 14980 .bool8Operands = {}, 14981 // int -> QUANT8_SYMM_PER_CHANNEL map 14982 .quant8ChannelOperands = {}, 14983 // int -> QUANT16_ASYMM map 14984 .quant16AsymmOperands = {}, 14985 // int -> QUANT8_SYMM map 14986 .quant8SymmOperands = {}, 14987 } 14988 }, 14989 }, // End of an example 14990 }; 14991 return examples_dynamic_output_shape_nchw_float16; 14992 }; 14993 14994 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_weight_as_input() { 14995 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_weight_as_input = { 14996 // Begin of an example 14997 { 14998 .operands = { 14999 //Input(s) 15000 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15001 // int -> Dimensions map 15002 .operandDimensions = {{0, {1, 1, 1, 2}}, {1, {1, 3, 3, 1}}, {2, {1}}}, 15003 // int -> FLOAT32 map 15004 .float32Operands = {}, 15005 // int -> INT32 map 15006 .int32Operands = {}, 15007 // int -> QUANT8_ASYMM map 15008 .quant8AsymmOperands = {}, 15009 // int -> QUANT16_SYMM map 15010 .quant16SymmOperands = {}, 15011 // int -> FLOAT16 map 15012 .float16Operands = {{0, {300.0f, 500.0f}}, {1, {9.0f, 5.0f, 6.0f, 9.0f, 8.0f, 5.0f, 3.0f, 1.0f, 4.0f}}, {2, {-1000.0f}}}, 15013 // int -> BOOL8 map 15014 .bool8Operands = {}, 15015 // int -> QUANT8_SYMM_PER_CHANNEL map 15016 .quant8ChannelOperands = {}, 15017 // int -> QUANT16_ASYMM map 15018 .quant16AsymmOperands = {}, 15019 // int -> QUANT8_SYMM map 15020 .quant8SymmOperands = {}, 15021 }, 15022 //Output(s) 15023 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15024 // int -> Dimensions map 15025 .operandDimensions = {{0, {1, 1, 3, 4}}}, 15026 // int -> FLOAT32 map 15027 .float32Operands = {}, 15028 // int -> INT32 map 15029 .int32Operands = {}, 15030 // int -> QUANT8_ASYMM map 15031 .quant8AsymmOperands = {}, 15032 // int -> QUANT16_SYMM map 15033 .quant16SymmOperands = {}, 15034 // int -> FLOAT16 map 15035 .float16Operands = {{0, {500.0f, 800.0f, 3500.0f, 1500.0f, 1400.0f, 500.0f, 3500.0f, 3000.0f, 0.0f, 200.0f, 500.0f, 0.0f}}}, 15036 // int -> BOOL8 map 15037 .bool8Operands = {}, 15038 // int -> QUANT8_SYMM_PER_CHANNEL map 15039 .quant8ChannelOperands = {}, 15040 // int -> QUANT16_ASYMM map 15041 .quant16AsymmOperands = {}, 15042 // int -> QUANT8_SYMM map 15043 .quant8SymmOperands = {}, 15044 } 15045 }, 15046 }, // End of an example 15047 }; 15048 return examples_dynamic_output_shape_nchw_float16_weight_as_input; 15049 }; 15050 15051 std::vector<MixedTypedExample>& get_examples_nhwc_2() { 15052 static std::vector<MixedTypedExample> examples_nhwc_2 = { 15053 // Begin of an example 15054 { 15055 .operands = { 15056 //Input(s) 15057 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15058 // int -> Dimensions map 15059 .operandDimensions = {{0, {1, 4, 4, 2}}}, 15060 // int -> FLOAT32 map 15061 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 15062 // int -> INT32 map 15063 .int32Operands = {}, 15064 // int -> QUANT8_ASYMM map 15065 .quant8AsymmOperands = {}, 15066 // int -> QUANT16_SYMM map 15067 .quant16SymmOperands = {}, 15068 // int -> FLOAT16 map 15069 .float16Operands = {}, 15070 // int -> BOOL8 map 15071 .bool8Operands = {}, 15072 // int -> QUANT8_SYMM_PER_CHANNEL map 15073 .quant8ChannelOperands = {}, 15074 // int -> QUANT16_ASYMM map 15075 .quant16AsymmOperands = {}, 15076 // int -> QUANT8_SYMM map 15077 .quant8SymmOperands = {}, 15078 }, 15079 //Output(s) 15080 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15081 // int -> Dimensions map 15082 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15083 // int -> FLOAT32 map 15084 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15085 // int -> INT32 map 15086 .int32Operands = {}, 15087 // int -> QUANT8_ASYMM map 15088 .quant8AsymmOperands = {}, 15089 // int -> QUANT16_SYMM map 15090 .quant16SymmOperands = {}, 15091 // int -> FLOAT16 map 15092 .float16Operands = {}, 15093 // int -> BOOL8 map 15094 .bool8Operands = {}, 15095 // int -> QUANT8_SYMM_PER_CHANNEL map 15096 .quant8ChannelOperands = {}, 15097 // int -> QUANT16_ASYMM map 15098 .quant16AsymmOperands = {}, 15099 // int -> QUANT8_SYMM map 15100 .quant8SymmOperands = {}, 15101 } 15102 }, 15103 }, // End of an example 15104 }; 15105 return examples_nhwc_2; 15106 }; 15107 15108 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_2() { 15109 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_2 = { 15110 // Begin of an example 15111 { 15112 .operands = { 15113 //Input(s) 15114 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15115 // int -> Dimensions map 15116 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15117 // int -> FLOAT32 map 15118 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15119 // int -> INT32 map 15120 .int32Operands = {}, 15121 // int -> QUANT8_ASYMM map 15122 .quant8AsymmOperands = {}, 15123 // int -> QUANT16_SYMM map 15124 .quant16SymmOperands = {}, 15125 // int -> FLOAT16 map 15126 .float16Operands = {}, 15127 // int -> BOOL8 map 15128 .bool8Operands = {}, 15129 // int -> QUANT8_SYMM_PER_CHANNEL map 15130 .quant8ChannelOperands = {}, 15131 // int -> QUANT16_ASYMM map 15132 .quant16AsymmOperands = {}, 15133 // int -> QUANT8_SYMM map 15134 .quant8SymmOperands = {}, 15135 }, 15136 //Output(s) 15137 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15138 // int -> Dimensions map 15139 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15140 // int -> FLOAT32 map 15141 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15142 // int -> INT32 map 15143 .int32Operands = {}, 15144 // int -> QUANT8_ASYMM map 15145 .quant8AsymmOperands = {}, 15146 // int -> QUANT16_SYMM map 15147 .quant16SymmOperands = {}, 15148 // int -> FLOAT16 map 15149 .float16Operands = {}, 15150 // int -> BOOL8 map 15151 .bool8Operands = {}, 15152 // int -> QUANT8_SYMM_PER_CHANNEL map 15153 .quant8ChannelOperands = {}, 15154 // int -> QUANT16_ASYMM map 15155 .quant16AsymmOperands = {}, 15156 // int -> QUANT8_SYMM map 15157 .quant8SymmOperands = {}, 15158 } 15159 }, 15160 }, // End of an example 15161 }; 15162 return examples_nhwc_weight_as_input_2; 15163 }; 15164 15165 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_2() { 15166 static std::vector<MixedTypedExample> examples_nhwc_relaxed_2 = { 15167 // Begin of an example 15168 { 15169 .operands = { 15170 //Input(s) 15171 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15172 // int -> Dimensions map 15173 .operandDimensions = {{0, {1, 4, 4, 2}}}, 15174 // int -> FLOAT32 map 15175 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 15176 // int -> INT32 map 15177 .int32Operands = {}, 15178 // int -> QUANT8_ASYMM map 15179 .quant8AsymmOperands = {}, 15180 // int -> QUANT16_SYMM map 15181 .quant16SymmOperands = {}, 15182 // int -> FLOAT16 map 15183 .float16Operands = {}, 15184 // int -> BOOL8 map 15185 .bool8Operands = {}, 15186 // int -> QUANT8_SYMM_PER_CHANNEL map 15187 .quant8ChannelOperands = {}, 15188 // int -> QUANT16_ASYMM map 15189 .quant16AsymmOperands = {}, 15190 // int -> QUANT8_SYMM map 15191 .quant8SymmOperands = {}, 15192 }, 15193 //Output(s) 15194 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15195 // int -> Dimensions map 15196 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15197 // int -> FLOAT32 map 15198 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15199 // int -> INT32 map 15200 .int32Operands = {}, 15201 // int -> QUANT8_ASYMM map 15202 .quant8AsymmOperands = {}, 15203 // int -> QUANT16_SYMM map 15204 .quant16SymmOperands = {}, 15205 // int -> FLOAT16 map 15206 .float16Operands = {}, 15207 // int -> BOOL8 map 15208 .bool8Operands = {}, 15209 // int -> QUANT8_SYMM_PER_CHANNEL map 15210 .quant8ChannelOperands = {}, 15211 // int -> QUANT16_ASYMM map 15212 .quant16AsymmOperands = {}, 15213 // int -> QUANT8_SYMM map 15214 .quant8SymmOperands = {}, 15215 } 15216 }, 15217 }, // End of an example 15218 }; 15219 return examples_nhwc_relaxed_2; 15220 }; 15221 15222 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_weight_as_input_2() { 15223 static std::vector<MixedTypedExample> examples_nhwc_relaxed_weight_as_input_2 = { 15224 // Begin of an example 15225 { 15226 .operands = { 15227 //Input(s) 15228 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15229 // int -> Dimensions map 15230 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15231 // int -> FLOAT32 map 15232 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15233 // int -> INT32 map 15234 .int32Operands = {}, 15235 // int -> QUANT8_ASYMM map 15236 .quant8AsymmOperands = {}, 15237 // int -> QUANT16_SYMM map 15238 .quant16SymmOperands = {}, 15239 // int -> FLOAT16 map 15240 .float16Operands = {}, 15241 // int -> BOOL8 map 15242 .bool8Operands = {}, 15243 // int -> QUANT8_SYMM_PER_CHANNEL map 15244 .quant8ChannelOperands = {}, 15245 // int -> QUANT16_ASYMM map 15246 .quant16AsymmOperands = {}, 15247 // int -> QUANT8_SYMM map 15248 .quant8SymmOperands = {}, 15249 }, 15250 //Output(s) 15251 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15252 // int -> Dimensions map 15253 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15254 // int -> FLOAT32 map 15255 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15256 // int -> INT32 map 15257 .int32Operands = {}, 15258 // int -> QUANT8_ASYMM map 15259 .quant8AsymmOperands = {}, 15260 // int -> QUANT16_SYMM map 15261 .quant16SymmOperands = {}, 15262 // int -> FLOAT16 map 15263 .float16Operands = {}, 15264 // int -> BOOL8 map 15265 .bool8Operands = {}, 15266 // int -> QUANT8_SYMM_PER_CHANNEL map 15267 .quant8ChannelOperands = {}, 15268 // int -> QUANT16_ASYMM map 15269 .quant16AsymmOperands = {}, 15270 // int -> QUANT8_SYMM map 15271 .quant8SymmOperands = {}, 15272 } 15273 }, 15274 }, // End of an example 15275 }; 15276 return examples_nhwc_relaxed_weight_as_input_2; 15277 }; 15278 15279 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_2() { 15280 static std::vector<MixedTypedExample> examples_nhwc_quant8_2 = { 15281 // Begin of an example 15282 { 15283 .operands = { 15284 //Input(s) 15285 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15286 // int -> Dimensions map 15287 .operandDimensions = {{0, {1, 4, 4, 2}}}, 15288 // int -> FLOAT32 map 15289 .float32Operands = {}, 15290 // int -> INT32 map 15291 .int32Operands = {}, 15292 // int -> QUANT8_ASYMM map 15293 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 15294 // int -> QUANT16_SYMM map 15295 .quant16SymmOperands = {}, 15296 // int -> FLOAT16 map 15297 .float16Operands = {}, 15298 // int -> BOOL8 map 15299 .bool8Operands = {}, 15300 // int -> QUANT8_SYMM_PER_CHANNEL map 15301 .quant8ChannelOperands = {}, 15302 // int -> QUANT16_ASYMM map 15303 .quant16AsymmOperands = {}, 15304 // int -> QUANT8_SYMM map 15305 .quant8SymmOperands = {}, 15306 }, 15307 //Output(s) 15308 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15309 // int -> Dimensions map 15310 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15311 // int -> FLOAT32 map 15312 .float32Operands = {}, 15313 // int -> INT32 map 15314 .int32Operands = {}, 15315 // int -> QUANT8_ASYMM map 15316 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 15317 // int -> QUANT16_SYMM map 15318 .quant16SymmOperands = {}, 15319 // int -> FLOAT16 map 15320 .float16Operands = {}, 15321 // int -> BOOL8 map 15322 .bool8Operands = {}, 15323 // int -> QUANT8_SYMM_PER_CHANNEL map 15324 .quant8ChannelOperands = {}, 15325 // int -> QUANT16_ASYMM map 15326 .quant16AsymmOperands = {}, 15327 // int -> QUANT8_SYMM map 15328 .quant8SymmOperands = {}, 15329 } 15330 }, 15331 }, // End of an example 15332 }; 15333 return examples_nhwc_quant8_2; 15334 }; 15335 15336 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_weight_as_input_2() { 15337 static std::vector<MixedTypedExample> examples_nhwc_quant8_weight_as_input_2 = { 15338 // Begin of an example 15339 { 15340 .operands = { 15341 //Input(s) 15342 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15343 // int -> Dimensions map 15344 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15345 // int -> FLOAT32 map 15346 .float32Operands = {}, 15347 // int -> INT32 map 15348 .int32Operands = {{2, {0}}}, 15349 // int -> QUANT8_ASYMM map 15350 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 15351 // int -> QUANT16_SYMM map 15352 .quant16SymmOperands = {}, 15353 // int -> FLOAT16 map 15354 .float16Operands = {}, 15355 // int -> BOOL8 map 15356 .bool8Operands = {}, 15357 // int -> QUANT8_SYMM_PER_CHANNEL map 15358 .quant8ChannelOperands = {}, 15359 // int -> QUANT16_ASYMM map 15360 .quant16AsymmOperands = {}, 15361 // int -> QUANT8_SYMM map 15362 .quant8SymmOperands = {}, 15363 }, 15364 //Output(s) 15365 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15366 // int -> Dimensions map 15367 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15368 // int -> FLOAT32 map 15369 .float32Operands = {}, 15370 // int -> INT32 map 15371 .int32Operands = {}, 15372 // int -> QUANT8_ASYMM map 15373 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 15374 // int -> QUANT16_SYMM map 15375 .quant16SymmOperands = {}, 15376 // int -> FLOAT16 map 15377 .float16Operands = {}, 15378 // int -> BOOL8 map 15379 .bool8Operands = {}, 15380 // int -> QUANT8_SYMM_PER_CHANNEL map 15381 .quant8ChannelOperands = {}, 15382 // int -> QUANT16_ASYMM map 15383 .quant16AsymmOperands = {}, 15384 // int -> QUANT8_SYMM map 15385 .quant8SymmOperands = {}, 15386 } 15387 }, 15388 }, // End of an example 15389 }; 15390 return examples_nhwc_quant8_weight_as_input_2; 15391 }; 15392 15393 std::vector<MixedTypedExample>& get_examples_nhwc_float16_2() { 15394 static std::vector<MixedTypedExample> examples_nhwc_float16_2 = { 15395 // Begin of an example 15396 { 15397 .operands = { 15398 //Input(s) 15399 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15400 // int -> Dimensions map 15401 .operandDimensions = {{0, {1, 4, 4, 2}}}, 15402 // int -> FLOAT32 map 15403 .float32Operands = {}, 15404 // int -> INT32 map 15405 .int32Operands = {}, 15406 // int -> QUANT8_ASYMM map 15407 .quant8AsymmOperands = {}, 15408 // int -> QUANT16_SYMM map 15409 .quant16SymmOperands = {}, 15410 // int -> FLOAT16 map 15411 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 15412 // int -> BOOL8 map 15413 .bool8Operands = {}, 15414 // int -> QUANT8_SYMM_PER_CHANNEL map 15415 .quant8ChannelOperands = {}, 15416 // int -> QUANT16_ASYMM map 15417 .quant16AsymmOperands = {}, 15418 // int -> QUANT8_SYMM map 15419 .quant8SymmOperands = {}, 15420 }, 15421 //Output(s) 15422 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15423 // int -> Dimensions map 15424 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15425 // int -> FLOAT32 map 15426 .float32Operands = {}, 15427 // int -> INT32 map 15428 .int32Operands = {}, 15429 // int -> QUANT8_ASYMM map 15430 .quant8AsymmOperands = {}, 15431 // int -> QUANT16_SYMM map 15432 .quant16SymmOperands = {}, 15433 // int -> FLOAT16 map 15434 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15435 // int -> BOOL8 map 15436 .bool8Operands = {}, 15437 // int -> QUANT8_SYMM_PER_CHANNEL map 15438 .quant8ChannelOperands = {}, 15439 // int -> QUANT16_ASYMM map 15440 .quant16AsymmOperands = {}, 15441 // int -> QUANT8_SYMM map 15442 .quant8SymmOperands = {}, 15443 } 15444 }, 15445 }, // End of an example 15446 }; 15447 return examples_nhwc_float16_2; 15448 }; 15449 15450 std::vector<MixedTypedExample>& get_examples_nhwc_float16_weight_as_input_2() { 15451 static std::vector<MixedTypedExample> examples_nhwc_float16_weight_as_input_2 = { 15452 // Begin of an example 15453 { 15454 .operands = { 15455 //Input(s) 15456 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15457 // int -> Dimensions map 15458 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15459 // int -> FLOAT32 map 15460 .float32Operands = {}, 15461 // int -> INT32 map 15462 .int32Operands = {}, 15463 // int -> QUANT8_ASYMM map 15464 .quant8AsymmOperands = {}, 15465 // int -> QUANT16_SYMM map 15466 .quant16SymmOperands = {}, 15467 // int -> FLOAT16 map 15468 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15469 // int -> BOOL8 map 15470 .bool8Operands = {}, 15471 // int -> QUANT8_SYMM_PER_CHANNEL map 15472 .quant8ChannelOperands = {}, 15473 // int -> QUANT16_ASYMM map 15474 .quant16AsymmOperands = {}, 15475 // int -> QUANT8_SYMM map 15476 .quant8SymmOperands = {}, 15477 }, 15478 //Output(s) 15479 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15480 // int -> Dimensions map 15481 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15482 // int -> FLOAT32 map 15483 .float32Operands = {}, 15484 // int -> INT32 map 15485 .int32Operands = {}, 15486 // int -> QUANT8_ASYMM map 15487 .quant8AsymmOperands = {}, 15488 // int -> QUANT16_SYMM map 15489 .quant16SymmOperands = {}, 15490 // int -> FLOAT16 map 15491 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15492 // int -> BOOL8 map 15493 .bool8Operands = {}, 15494 // int -> QUANT8_SYMM_PER_CHANNEL map 15495 .quant8ChannelOperands = {}, 15496 // int -> QUANT16_ASYMM map 15497 .quant16AsymmOperands = {}, 15498 // int -> QUANT8_SYMM map 15499 .quant8SymmOperands = {}, 15500 } 15501 }, 15502 }, // End of an example 15503 }; 15504 return examples_nhwc_float16_weight_as_input_2; 15505 }; 15506 15507 std::vector<MixedTypedExample>& get_examples_nchw_2() { 15508 static std::vector<MixedTypedExample> examples_nchw_2 = { 15509 // Begin of an example 15510 { 15511 .operands = { 15512 //Input(s) 15513 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15514 // int -> Dimensions map 15515 .operandDimensions = {{0, {1, 2, 4, 4}}}, 15516 // int -> FLOAT32 map 15517 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 15518 // int -> INT32 map 15519 .int32Operands = {}, 15520 // int -> QUANT8_ASYMM map 15521 .quant8AsymmOperands = {}, 15522 // int -> QUANT16_SYMM map 15523 .quant16SymmOperands = {}, 15524 // int -> FLOAT16 map 15525 .float16Operands = {}, 15526 // int -> BOOL8 map 15527 .bool8Operands = {}, 15528 // int -> QUANT8_SYMM_PER_CHANNEL map 15529 .quant8ChannelOperands = {}, 15530 // int -> QUANT16_ASYMM map 15531 .quant16AsymmOperands = {}, 15532 // int -> QUANT8_SYMM map 15533 .quant8SymmOperands = {}, 15534 }, 15535 //Output(s) 15536 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15537 // int -> Dimensions map 15538 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15539 // int -> FLOAT32 map 15540 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15541 // int -> INT32 map 15542 .int32Operands = {}, 15543 // int -> QUANT8_ASYMM map 15544 .quant8AsymmOperands = {}, 15545 // int -> QUANT16_SYMM map 15546 .quant16SymmOperands = {}, 15547 // int -> FLOAT16 map 15548 .float16Operands = {}, 15549 // int -> BOOL8 map 15550 .bool8Operands = {}, 15551 // int -> QUANT8_SYMM_PER_CHANNEL map 15552 .quant8ChannelOperands = {}, 15553 // int -> QUANT16_ASYMM map 15554 .quant16AsymmOperands = {}, 15555 // int -> QUANT8_SYMM map 15556 .quant8SymmOperands = {}, 15557 } 15558 }, 15559 }, // End of an example 15560 }; 15561 return examples_nchw_2; 15562 }; 15563 15564 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_2() { 15565 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_2 = { 15566 // Begin of an example 15567 { 15568 .operands = { 15569 //Input(s) 15570 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15571 // int -> Dimensions map 15572 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15573 // int -> FLOAT32 map 15574 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15575 // int -> INT32 map 15576 .int32Operands = {}, 15577 // int -> QUANT8_ASYMM map 15578 .quant8AsymmOperands = {}, 15579 // int -> QUANT16_SYMM map 15580 .quant16SymmOperands = {}, 15581 // int -> FLOAT16 map 15582 .float16Operands = {}, 15583 // int -> BOOL8 map 15584 .bool8Operands = {}, 15585 // int -> QUANT8_SYMM_PER_CHANNEL map 15586 .quant8ChannelOperands = {}, 15587 // int -> QUANT16_ASYMM map 15588 .quant16AsymmOperands = {}, 15589 // int -> QUANT8_SYMM map 15590 .quant8SymmOperands = {}, 15591 }, 15592 //Output(s) 15593 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15594 // int -> Dimensions map 15595 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15596 // int -> FLOAT32 map 15597 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15598 // int -> INT32 map 15599 .int32Operands = {}, 15600 // int -> QUANT8_ASYMM map 15601 .quant8AsymmOperands = {}, 15602 // int -> QUANT16_SYMM map 15603 .quant16SymmOperands = {}, 15604 // int -> FLOAT16 map 15605 .float16Operands = {}, 15606 // int -> BOOL8 map 15607 .bool8Operands = {}, 15608 // int -> QUANT8_SYMM_PER_CHANNEL map 15609 .quant8ChannelOperands = {}, 15610 // int -> QUANT16_ASYMM map 15611 .quant16AsymmOperands = {}, 15612 // int -> QUANT8_SYMM map 15613 .quant8SymmOperands = {}, 15614 } 15615 }, 15616 }, // End of an example 15617 }; 15618 return examples_nchw_weight_as_input_2; 15619 }; 15620 15621 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_2() { 15622 static std::vector<MixedTypedExample> examples_nchw_relaxed_2 = { 15623 // Begin of an example 15624 { 15625 .operands = { 15626 //Input(s) 15627 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15628 // int -> Dimensions map 15629 .operandDimensions = {{0, {1, 2, 4, 4}}}, 15630 // int -> FLOAT32 map 15631 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 15632 // int -> INT32 map 15633 .int32Operands = {}, 15634 // int -> QUANT8_ASYMM map 15635 .quant8AsymmOperands = {}, 15636 // int -> QUANT16_SYMM map 15637 .quant16SymmOperands = {}, 15638 // int -> FLOAT16 map 15639 .float16Operands = {}, 15640 // int -> BOOL8 map 15641 .bool8Operands = {}, 15642 // int -> QUANT8_SYMM_PER_CHANNEL map 15643 .quant8ChannelOperands = {}, 15644 // int -> QUANT16_ASYMM map 15645 .quant16AsymmOperands = {}, 15646 // int -> QUANT8_SYMM map 15647 .quant8SymmOperands = {}, 15648 }, 15649 //Output(s) 15650 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15651 // int -> Dimensions map 15652 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15653 // int -> FLOAT32 map 15654 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15655 // int -> INT32 map 15656 .int32Operands = {}, 15657 // int -> QUANT8_ASYMM map 15658 .quant8AsymmOperands = {}, 15659 // int -> QUANT16_SYMM map 15660 .quant16SymmOperands = {}, 15661 // int -> FLOAT16 map 15662 .float16Operands = {}, 15663 // int -> BOOL8 map 15664 .bool8Operands = {}, 15665 // int -> QUANT8_SYMM_PER_CHANNEL map 15666 .quant8ChannelOperands = {}, 15667 // int -> QUANT16_ASYMM map 15668 .quant16AsymmOperands = {}, 15669 // int -> QUANT8_SYMM map 15670 .quant8SymmOperands = {}, 15671 } 15672 }, 15673 }, // End of an example 15674 }; 15675 return examples_nchw_relaxed_2; 15676 }; 15677 15678 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_weight_as_input_2() { 15679 static std::vector<MixedTypedExample> examples_nchw_relaxed_weight_as_input_2 = { 15680 // Begin of an example 15681 { 15682 .operands = { 15683 //Input(s) 15684 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15685 // int -> Dimensions map 15686 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15687 // int -> FLOAT32 map 15688 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15689 // int -> INT32 map 15690 .int32Operands = {}, 15691 // int -> QUANT8_ASYMM map 15692 .quant8AsymmOperands = {}, 15693 // int -> QUANT16_SYMM map 15694 .quant16SymmOperands = {}, 15695 // int -> FLOAT16 map 15696 .float16Operands = {}, 15697 // int -> BOOL8 map 15698 .bool8Operands = {}, 15699 // int -> QUANT8_SYMM_PER_CHANNEL map 15700 .quant8ChannelOperands = {}, 15701 // int -> QUANT16_ASYMM map 15702 .quant16AsymmOperands = {}, 15703 // int -> QUANT8_SYMM map 15704 .quant8SymmOperands = {}, 15705 }, 15706 //Output(s) 15707 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15708 // int -> Dimensions map 15709 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15710 // int -> FLOAT32 map 15711 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15712 // int -> INT32 map 15713 .int32Operands = {}, 15714 // int -> QUANT8_ASYMM map 15715 .quant8AsymmOperands = {}, 15716 // int -> QUANT16_SYMM map 15717 .quant16SymmOperands = {}, 15718 // int -> FLOAT16 map 15719 .float16Operands = {}, 15720 // int -> BOOL8 map 15721 .bool8Operands = {}, 15722 // int -> QUANT8_SYMM_PER_CHANNEL map 15723 .quant8ChannelOperands = {}, 15724 // int -> QUANT16_ASYMM map 15725 .quant16AsymmOperands = {}, 15726 // int -> QUANT8_SYMM map 15727 .quant8SymmOperands = {}, 15728 } 15729 }, 15730 }, // End of an example 15731 }; 15732 return examples_nchw_relaxed_weight_as_input_2; 15733 }; 15734 15735 std::vector<MixedTypedExample>& get_examples_nchw_quant8_2() { 15736 static std::vector<MixedTypedExample> examples_nchw_quant8_2 = { 15737 // Begin of an example 15738 { 15739 .operands = { 15740 //Input(s) 15741 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15742 // int -> Dimensions map 15743 .operandDimensions = {{0, {1, 2, 4, 4}}}, 15744 // int -> FLOAT32 map 15745 .float32Operands = {}, 15746 // int -> INT32 map 15747 .int32Operands = {}, 15748 // int -> QUANT8_ASYMM map 15749 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 15750 // int -> QUANT16_SYMM map 15751 .quant16SymmOperands = {}, 15752 // int -> FLOAT16 map 15753 .float16Operands = {}, 15754 // int -> BOOL8 map 15755 .bool8Operands = {}, 15756 // int -> QUANT8_SYMM_PER_CHANNEL map 15757 .quant8ChannelOperands = {}, 15758 // int -> QUANT16_ASYMM map 15759 .quant16AsymmOperands = {}, 15760 // int -> QUANT8_SYMM map 15761 .quant8SymmOperands = {}, 15762 }, 15763 //Output(s) 15764 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15765 // int -> Dimensions map 15766 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15767 // int -> FLOAT32 map 15768 .float32Operands = {}, 15769 // int -> INT32 map 15770 .int32Operands = {}, 15771 // int -> QUANT8_ASYMM map 15772 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 15773 // int -> QUANT16_SYMM map 15774 .quant16SymmOperands = {}, 15775 // int -> FLOAT16 map 15776 .float16Operands = {}, 15777 // int -> BOOL8 map 15778 .bool8Operands = {}, 15779 // int -> QUANT8_SYMM_PER_CHANNEL map 15780 .quant8ChannelOperands = {}, 15781 // int -> QUANT16_ASYMM map 15782 .quant16AsymmOperands = {}, 15783 // int -> QUANT8_SYMM map 15784 .quant8SymmOperands = {}, 15785 } 15786 }, 15787 }, // End of an example 15788 }; 15789 return examples_nchw_quant8_2; 15790 }; 15791 15792 std::vector<MixedTypedExample>& get_examples_nchw_quant8_weight_as_input_2() { 15793 static std::vector<MixedTypedExample> examples_nchw_quant8_weight_as_input_2 = { 15794 // Begin of an example 15795 { 15796 .operands = { 15797 //Input(s) 15798 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15799 // int -> Dimensions map 15800 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15801 // int -> FLOAT32 map 15802 .float32Operands = {}, 15803 // int -> INT32 map 15804 .int32Operands = {{2, {0}}}, 15805 // int -> QUANT8_ASYMM map 15806 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 15807 // int -> QUANT16_SYMM map 15808 .quant16SymmOperands = {}, 15809 // int -> FLOAT16 map 15810 .float16Operands = {}, 15811 // int -> BOOL8 map 15812 .bool8Operands = {}, 15813 // int -> QUANT8_SYMM_PER_CHANNEL map 15814 .quant8ChannelOperands = {}, 15815 // int -> QUANT16_ASYMM map 15816 .quant16AsymmOperands = {}, 15817 // int -> QUANT8_SYMM map 15818 .quant8SymmOperands = {}, 15819 }, 15820 //Output(s) 15821 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15822 // int -> Dimensions map 15823 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15824 // int -> FLOAT32 map 15825 .float32Operands = {}, 15826 // int -> INT32 map 15827 .int32Operands = {}, 15828 // int -> QUANT8_ASYMM map 15829 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 15830 // int -> QUANT16_SYMM map 15831 .quant16SymmOperands = {}, 15832 // int -> FLOAT16 map 15833 .float16Operands = {}, 15834 // int -> BOOL8 map 15835 .bool8Operands = {}, 15836 // int -> QUANT8_SYMM_PER_CHANNEL map 15837 .quant8ChannelOperands = {}, 15838 // int -> QUANT16_ASYMM map 15839 .quant16AsymmOperands = {}, 15840 // int -> QUANT8_SYMM map 15841 .quant8SymmOperands = {}, 15842 } 15843 }, 15844 }, // End of an example 15845 }; 15846 return examples_nchw_quant8_weight_as_input_2; 15847 }; 15848 15849 std::vector<MixedTypedExample>& get_examples_nchw_float16_2() { 15850 static std::vector<MixedTypedExample> examples_nchw_float16_2 = { 15851 // Begin of an example 15852 { 15853 .operands = { 15854 //Input(s) 15855 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15856 // int -> Dimensions map 15857 .operandDimensions = {{0, {1, 2, 4, 4}}}, 15858 // int -> FLOAT32 map 15859 .float32Operands = {}, 15860 // int -> INT32 map 15861 .int32Operands = {}, 15862 // int -> QUANT8_ASYMM map 15863 .quant8AsymmOperands = {}, 15864 // int -> QUANT16_SYMM map 15865 .quant16SymmOperands = {}, 15866 // int -> FLOAT16 map 15867 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 15868 // int -> BOOL8 map 15869 .bool8Operands = {}, 15870 // int -> QUANT8_SYMM_PER_CHANNEL map 15871 .quant8ChannelOperands = {}, 15872 // int -> QUANT16_ASYMM map 15873 .quant16AsymmOperands = {}, 15874 // int -> QUANT8_SYMM map 15875 .quant8SymmOperands = {}, 15876 }, 15877 //Output(s) 15878 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15879 // int -> Dimensions map 15880 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15881 // int -> FLOAT32 map 15882 .float32Operands = {}, 15883 // int -> INT32 map 15884 .int32Operands = {}, 15885 // int -> QUANT8_ASYMM map 15886 .quant8AsymmOperands = {}, 15887 // int -> QUANT16_SYMM map 15888 .quant16SymmOperands = {}, 15889 // int -> FLOAT16 map 15890 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15891 // int -> BOOL8 map 15892 .bool8Operands = {}, 15893 // int -> QUANT8_SYMM_PER_CHANNEL map 15894 .quant8ChannelOperands = {}, 15895 // int -> QUANT16_ASYMM map 15896 .quant16AsymmOperands = {}, 15897 // int -> QUANT8_SYMM map 15898 .quant8SymmOperands = {}, 15899 } 15900 }, 15901 }, // End of an example 15902 }; 15903 return examples_nchw_float16_2; 15904 }; 15905 15906 std::vector<MixedTypedExample>& get_examples_nchw_float16_weight_as_input_2() { 15907 static std::vector<MixedTypedExample> examples_nchw_float16_weight_as_input_2 = { 15908 // Begin of an example 15909 { 15910 .operands = { 15911 //Input(s) 15912 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15913 // int -> Dimensions map 15914 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 15915 // int -> FLOAT32 map 15916 .float32Operands = {}, 15917 // int -> INT32 map 15918 .int32Operands = {}, 15919 // int -> QUANT8_ASYMM map 15920 .quant8AsymmOperands = {}, 15921 // int -> QUANT16_SYMM map 15922 .quant16SymmOperands = {}, 15923 // int -> FLOAT16 map 15924 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 15925 // int -> BOOL8 map 15926 .bool8Operands = {}, 15927 // int -> QUANT8_SYMM_PER_CHANNEL map 15928 .quant8ChannelOperands = {}, 15929 // int -> QUANT16_ASYMM map 15930 .quant16AsymmOperands = {}, 15931 // int -> QUANT8_SYMM map 15932 .quant8SymmOperands = {}, 15933 }, 15934 //Output(s) 15935 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15936 // int -> Dimensions map 15937 .operandDimensions = {{0, {1, 1, 4, 4}}}, 15938 // int -> FLOAT32 map 15939 .float32Operands = {}, 15940 // int -> INT32 map 15941 .int32Operands = {}, 15942 // int -> QUANT8_ASYMM map 15943 .quant8AsymmOperands = {}, 15944 // int -> QUANT16_SYMM map 15945 .quant16SymmOperands = {}, 15946 // int -> FLOAT16 map 15947 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15948 // int -> BOOL8 map 15949 .bool8Operands = {}, 15950 // int -> QUANT8_SYMM_PER_CHANNEL map 15951 .quant8ChannelOperands = {}, 15952 // int -> QUANT16_ASYMM map 15953 .quant16AsymmOperands = {}, 15954 // int -> QUANT8_SYMM map 15955 .quant8SymmOperands = {}, 15956 } 15957 }, 15958 }, // End of an example 15959 }; 15960 return examples_nchw_float16_weight_as_input_2; 15961 }; 15962 15963 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_2() { 15964 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_2 = { 15965 // Begin of an example 15966 { 15967 .operands = { 15968 //Input(s) 15969 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15970 // int -> Dimensions map 15971 .operandDimensions = {{0, {1, 4, 4, 2}}}, 15972 // int -> FLOAT32 map 15973 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 15974 // int -> INT32 map 15975 .int32Operands = {}, 15976 // int -> QUANT8_ASYMM map 15977 .quant8AsymmOperands = {}, 15978 // int -> QUANT16_SYMM map 15979 .quant16SymmOperands = {}, 15980 // int -> FLOAT16 map 15981 .float16Operands = {}, 15982 // int -> BOOL8 map 15983 .bool8Operands = {}, 15984 // int -> QUANT8_SYMM_PER_CHANNEL map 15985 .quant8ChannelOperands = {}, 15986 // int -> QUANT16_ASYMM map 15987 .quant16AsymmOperands = {}, 15988 // int -> QUANT8_SYMM map 15989 .quant8SymmOperands = {}, 15990 }, 15991 //Output(s) 15992 { // See tools/test_generator/include/TestHarness.h:MixedTyped 15993 // int -> Dimensions map 15994 .operandDimensions = {{0, {1, 4, 4, 1}}}, 15995 // int -> FLOAT32 map 15996 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 15997 // int -> INT32 map 15998 .int32Operands = {}, 15999 // int -> QUANT8_ASYMM map 16000 .quant8AsymmOperands = {}, 16001 // int -> QUANT16_SYMM map 16002 .quant16SymmOperands = {}, 16003 // int -> FLOAT16 map 16004 .float16Operands = {}, 16005 // int -> BOOL8 map 16006 .bool8Operands = {}, 16007 // int -> QUANT8_SYMM_PER_CHANNEL map 16008 .quant8ChannelOperands = {}, 16009 // int -> QUANT16_ASYMM map 16010 .quant16AsymmOperands = {}, 16011 // int -> QUANT8_SYMM map 16012 .quant8SymmOperands = {}, 16013 } 16014 }, 16015 }, // End of an example 16016 }; 16017 return examples_dynamic_output_shape_nhwc_2; 16018 }; 16019 16020 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_2() { 16021 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_2 = { 16022 // Begin of an example 16023 { 16024 .operands = { 16025 //Input(s) 16026 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16027 // int -> Dimensions map 16028 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16029 // int -> FLOAT32 map 16030 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16031 // int -> INT32 map 16032 .int32Operands = {}, 16033 // int -> QUANT8_ASYMM map 16034 .quant8AsymmOperands = {}, 16035 // int -> QUANT16_SYMM map 16036 .quant16SymmOperands = {}, 16037 // int -> FLOAT16 map 16038 .float16Operands = {}, 16039 // int -> BOOL8 map 16040 .bool8Operands = {}, 16041 // int -> QUANT8_SYMM_PER_CHANNEL map 16042 .quant8ChannelOperands = {}, 16043 // int -> QUANT16_ASYMM map 16044 .quant16AsymmOperands = {}, 16045 // int -> QUANT8_SYMM map 16046 .quant8SymmOperands = {}, 16047 }, 16048 //Output(s) 16049 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16050 // int -> Dimensions map 16051 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16052 // int -> FLOAT32 map 16053 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16054 // int -> INT32 map 16055 .int32Operands = {}, 16056 // int -> QUANT8_ASYMM map 16057 .quant8AsymmOperands = {}, 16058 // int -> QUANT16_SYMM map 16059 .quant16SymmOperands = {}, 16060 // int -> FLOAT16 map 16061 .float16Operands = {}, 16062 // int -> BOOL8 map 16063 .bool8Operands = {}, 16064 // int -> QUANT8_SYMM_PER_CHANNEL map 16065 .quant8ChannelOperands = {}, 16066 // int -> QUANT16_ASYMM map 16067 .quant16AsymmOperands = {}, 16068 // int -> QUANT8_SYMM map 16069 .quant8SymmOperands = {}, 16070 } 16071 }, 16072 }, // End of an example 16073 }; 16074 return examples_dynamic_output_shape_nhwc_weight_as_input_2; 16075 }; 16076 16077 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_2() { 16078 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_2 = { 16079 // Begin of an example 16080 { 16081 .operands = { 16082 //Input(s) 16083 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16084 // int -> Dimensions map 16085 .operandDimensions = {{0, {1, 4, 4, 2}}}, 16086 // int -> FLOAT32 map 16087 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 16088 // int -> INT32 map 16089 .int32Operands = {}, 16090 // int -> QUANT8_ASYMM map 16091 .quant8AsymmOperands = {}, 16092 // int -> QUANT16_SYMM map 16093 .quant16SymmOperands = {}, 16094 // int -> FLOAT16 map 16095 .float16Operands = {}, 16096 // int -> BOOL8 map 16097 .bool8Operands = {}, 16098 // int -> QUANT8_SYMM_PER_CHANNEL map 16099 .quant8ChannelOperands = {}, 16100 // int -> QUANT16_ASYMM map 16101 .quant16AsymmOperands = {}, 16102 // int -> QUANT8_SYMM map 16103 .quant8SymmOperands = {}, 16104 }, 16105 //Output(s) 16106 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16107 // int -> Dimensions map 16108 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16109 // int -> FLOAT32 map 16110 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16111 // int -> INT32 map 16112 .int32Operands = {}, 16113 // int -> QUANT8_ASYMM map 16114 .quant8AsymmOperands = {}, 16115 // int -> QUANT16_SYMM map 16116 .quant16SymmOperands = {}, 16117 // int -> FLOAT16 map 16118 .float16Operands = {}, 16119 // int -> BOOL8 map 16120 .bool8Operands = {}, 16121 // int -> QUANT8_SYMM_PER_CHANNEL map 16122 .quant8ChannelOperands = {}, 16123 // int -> QUANT16_ASYMM map 16124 .quant16AsymmOperands = {}, 16125 // int -> QUANT8_SYMM map 16126 .quant8SymmOperands = {}, 16127 } 16128 }, 16129 }, // End of an example 16130 }; 16131 return examples_dynamic_output_shape_nhwc_relaxed_2; 16132 }; 16133 16134 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_2() { 16135 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_2 = { 16136 // Begin of an example 16137 { 16138 .operands = { 16139 //Input(s) 16140 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16141 // int -> Dimensions map 16142 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16143 // int -> FLOAT32 map 16144 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16145 // int -> INT32 map 16146 .int32Operands = {}, 16147 // int -> QUANT8_ASYMM map 16148 .quant8AsymmOperands = {}, 16149 // int -> QUANT16_SYMM map 16150 .quant16SymmOperands = {}, 16151 // int -> FLOAT16 map 16152 .float16Operands = {}, 16153 // int -> BOOL8 map 16154 .bool8Operands = {}, 16155 // int -> QUANT8_SYMM_PER_CHANNEL map 16156 .quant8ChannelOperands = {}, 16157 // int -> QUANT16_ASYMM map 16158 .quant16AsymmOperands = {}, 16159 // int -> QUANT8_SYMM map 16160 .quant8SymmOperands = {}, 16161 }, 16162 //Output(s) 16163 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16164 // int -> Dimensions map 16165 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16166 // int -> FLOAT32 map 16167 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16168 // int -> INT32 map 16169 .int32Operands = {}, 16170 // int -> QUANT8_ASYMM map 16171 .quant8AsymmOperands = {}, 16172 // int -> QUANT16_SYMM map 16173 .quant16SymmOperands = {}, 16174 // int -> FLOAT16 map 16175 .float16Operands = {}, 16176 // int -> BOOL8 map 16177 .bool8Operands = {}, 16178 // int -> QUANT8_SYMM_PER_CHANNEL map 16179 .quant8ChannelOperands = {}, 16180 // int -> QUANT16_ASYMM map 16181 .quant16AsymmOperands = {}, 16182 // int -> QUANT8_SYMM map 16183 .quant8SymmOperands = {}, 16184 } 16185 }, 16186 }, // End of an example 16187 }; 16188 return examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_2; 16189 }; 16190 16191 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_2() { 16192 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_2 = { 16193 // Begin of an example 16194 { 16195 .operands = { 16196 //Input(s) 16197 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16198 // int -> Dimensions map 16199 .operandDimensions = {{0, {1, 4, 4, 2}}}, 16200 // int -> FLOAT32 map 16201 .float32Operands = {}, 16202 // int -> INT32 map 16203 .int32Operands = {}, 16204 // int -> QUANT8_ASYMM map 16205 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 16206 // int -> QUANT16_SYMM map 16207 .quant16SymmOperands = {}, 16208 // int -> FLOAT16 map 16209 .float16Operands = {}, 16210 // int -> BOOL8 map 16211 .bool8Operands = {}, 16212 // int -> QUANT8_SYMM_PER_CHANNEL map 16213 .quant8ChannelOperands = {}, 16214 // int -> QUANT16_ASYMM map 16215 .quant16AsymmOperands = {}, 16216 // int -> QUANT8_SYMM map 16217 .quant8SymmOperands = {}, 16218 }, 16219 //Output(s) 16220 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16221 // int -> Dimensions map 16222 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16223 // int -> FLOAT32 map 16224 .float32Operands = {}, 16225 // int -> INT32 map 16226 .int32Operands = {}, 16227 // int -> QUANT8_ASYMM map 16228 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 16229 // int -> QUANT16_SYMM map 16230 .quant16SymmOperands = {}, 16231 // int -> FLOAT16 map 16232 .float16Operands = {}, 16233 // int -> BOOL8 map 16234 .bool8Operands = {}, 16235 // int -> QUANT8_SYMM_PER_CHANNEL map 16236 .quant8ChannelOperands = {}, 16237 // int -> QUANT16_ASYMM map 16238 .quant16AsymmOperands = {}, 16239 // int -> QUANT8_SYMM map 16240 .quant8SymmOperands = {}, 16241 } 16242 }, 16243 }, // End of an example 16244 }; 16245 return examples_dynamic_output_shape_nhwc_quant8_2; 16246 }; 16247 16248 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_weight_as_input_2() { 16249 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_weight_as_input_2 = { 16250 // Begin of an example 16251 { 16252 .operands = { 16253 //Input(s) 16254 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16255 // int -> Dimensions map 16256 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16257 // int -> FLOAT32 map 16258 .float32Operands = {}, 16259 // int -> INT32 map 16260 .int32Operands = {{2, {0}}}, 16261 // int -> QUANT8_ASYMM map 16262 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 16263 // int -> QUANT16_SYMM map 16264 .quant16SymmOperands = {}, 16265 // int -> FLOAT16 map 16266 .float16Operands = {}, 16267 // int -> BOOL8 map 16268 .bool8Operands = {}, 16269 // int -> QUANT8_SYMM_PER_CHANNEL map 16270 .quant8ChannelOperands = {}, 16271 // int -> QUANT16_ASYMM map 16272 .quant16AsymmOperands = {}, 16273 // int -> QUANT8_SYMM map 16274 .quant8SymmOperands = {}, 16275 }, 16276 //Output(s) 16277 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16278 // int -> Dimensions map 16279 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16280 // int -> FLOAT32 map 16281 .float32Operands = {}, 16282 // int -> INT32 map 16283 .int32Operands = {}, 16284 // int -> QUANT8_ASYMM map 16285 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 16286 // int -> QUANT16_SYMM map 16287 .quant16SymmOperands = {}, 16288 // int -> FLOAT16 map 16289 .float16Operands = {}, 16290 // int -> BOOL8 map 16291 .bool8Operands = {}, 16292 // int -> QUANT8_SYMM_PER_CHANNEL map 16293 .quant8ChannelOperands = {}, 16294 // int -> QUANT16_ASYMM map 16295 .quant16AsymmOperands = {}, 16296 // int -> QUANT8_SYMM map 16297 .quant8SymmOperands = {}, 16298 } 16299 }, 16300 }, // End of an example 16301 }; 16302 return examples_dynamic_output_shape_nhwc_quant8_weight_as_input_2; 16303 }; 16304 16305 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_2() { 16306 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_2 = { 16307 // Begin of an example 16308 { 16309 .operands = { 16310 //Input(s) 16311 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16312 // int -> Dimensions map 16313 .operandDimensions = {{0, {1, 4, 4, 2}}}, 16314 // int -> FLOAT32 map 16315 .float32Operands = {}, 16316 // int -> INT32 map 16317 .int32Operands = {}, 16318 // int -> QUANT8_ASYMM map 16319 .quant8AsymmOperands = {}, 16320 // int -> QUANT16_SYMM map 16321 .quant16SymmOperands = {}, 16322 // int -> FLOAT16 map 16323 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 16324 // int -> BOOL8 map 16325 .bool8Operands = {}, 16326 // int -> QUANT8_SYMM_PER_CHANNEL map 16327 .quant8ChannelOperands = {}, 16328 // int -> QUANT16_ASYMM map 16329 .quant16AsymmOperands = {}, 16330 // int -> QUANT8_SYMM map 16331 .quant8SymmOperands = {}, 16332 }, 16333 //Output(s) 16334 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16335 // int -> Dimensions map 16336 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16337 // int -> FLOAT32 map 16338 .float32Operands = {}, 16339 // int -> INT32 map 16340 .int32Operands = {}, 16341 // int -> QUANT8_ASYMM map 16342 .quant8AsymmOperands = {}, 16343 // int -> QUANT16_SYMM map 16344 .quant16SymmOperands = {}, 16345 // int -> FLOAT16 map 16346 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16347 // int -> BOOL8 map 16348 .bool8Operands = {}, 16349 // int -> QUANT8_SYMM_PER_CHANNEL map 16350 .quant8ChannelOperands = {}, 16351 // int -> QUANT16_ASYMM map 16352 .quant16AsymmOperands = {}, 16353 // int -> QUANT8_SYMM map 16354 .quant8SymmOperands = {}, 16355 } 16356 }, 16357 }, // End of an example 16358 }; 16359 return examples_dynamic_output_shape_nhwc_float16_2; 16360 }; 16361 16362 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_weight_as_input_2() { 16363 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_weight_as_input_2 = { 16364 // Begin of an example 16365 { 16366 .operands = { 16367 //Input(s) 16368 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16369 // int -> Dimensions map 16370 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16371 // int -> FLOAT32 map 16372 .float32Operands = {}, 16373 // int -> INT32 map 16374 .int32Operands = {}, 16375 // int -> QUANT8_ASYMM map 16376 .quant8AsymmOperands = {}, 16377 // int -> QUANT16_SYMM map 16378 .quant16SymmOperands = {}, 16379 // int -> FLOAT16 map 16380 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16381 // int -> BOOL8 map 16382 .bool8Operands = {}, 16383 // int -> QUANT8_SYMM_PER_CHANNEL map 16384 .quant8ChannelOperands = {}, 16385 // int -> QUANT16_ASYMM map 16386 .quant16AsymmOperands = {}, 16387 // int -> QUANT8_SYMM map 16388 .quant8SymmOperands = {}, 16389 }, 16390 //Output(s) 16391 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16392 // int -> Dimensions map 16393 .operandDimensions = {{0, {1, 4, 4, 1}}}, 16394 // int -> FLOAT32 map 16395 .float32Operands = {}, 16396 // int -> INT32 map 16397 .int32Operands = {}, 16398 // int -> QUANT8_ASYMM map 16399 .quant8AsymmOperands = {}, 16400 // int -> QUANT16_SYMM map 16401 .quant16SymmOperands = {}, 16402 // int -> FLOAT16 map 16403 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16404 // int -> BOOL8 map 16405 .bool8Operands = {}, 16406 // int -> QUANT8_SYMM_PER_CHANNEL map 16407 .quant8ChannelOperands = {}, 16408 // int -> QUANT16_ASYMM map 16409 .quant16AsymmOperands = {}, 16410 // int -> QUANT8_SYMM map 16411 .quant8SymmOperands = {}, 16412 } 16413 }, 16414 }, // End of an example 16415 }; 16416 return examples_dynamic_output_shape_nhwc_float16_weight_as_input_2; 16417 }; 16418 16419 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_2() { 16420 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_2 = { 16421 // Begin of an example 16422 { 16423 .operands = { 16424 //Input(s) 16425 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16426 // int -> Dimensions map 16427 .operandDimensions = {{0, {1, 2, 4, 4}}}, 16428 // int -> FLOAT32 map 16429 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 16430 // int -> INT32 map 16431 .int32Operands = {}, 16432 // int -> QUANT8_ASYMM map 16433 .quant8AsymmOperands = {}, 16434 // int -> QUANT16_SYMM map 16435 .quant16SymmOperands = {}, 16436 // int -> FLOAT16 map 16437 .float16Operands = {}, 16438 // int -> BOOL8 map 16439 .bool8Operands = {}, 16440 // int -> QUANT8_SYMM_PER_CHANNEL map 16441 .quant8ChannelOperands = {}, 16442 // int -> QUANT16_ASYMM map 16443 .quant16AsymmOperands = {}, 16444 // int -> QUANT8_SYMM map 16445 .quant8SymmOperands = {}, 16446 }, 16447 //Output(s) 16448 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16449 // int -> Dimensions map 16450 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16451 // int -> FLOAT32 map 16452 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16453 // int -> INT32 map 16454 .int32Operands = {}, 16455 // int -> QUANT8_ASYMM map 16456 .quant8AsymmOperands = {}, 16457 // int -> QUANT16_SYMM map 16458 .quant16SymmOperands = {}, 16459 // int -> FLOAT16 map 16460 .float16Operands = {}, 16461 // int -> BOOL8 map 16462 .bool8Operands = {}, 16463 // int -> QUANT8_SYMM_PER_CHANNEL map 16464 .quant8ChannelOperands = {}, 16465 // int -> QUANT16_ASYMM map 16466 .quant16AsymmOperands = {}, 16467 // int -> QUANT8_SYMM map 16468 .quant8SymmOperands = {}, 16469 } 16470 }, 16471 }, // End of an example 16472 }; 16473 return examples_dynamic_output_shape_nchw_2; 16474 }; 16475 16476 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_2() { 16477 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_2 = { 16478 // Begin of an example 16479 { 16480 .operands = { 16481 //Input(s) 16482 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16483 // int -> Dimensions map 16484 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16485 // int -> FLOAT32 map 16486 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16487 // int -> INT32 map 16488 .int32Operands = {}, 16489 // int -> QUANT8_ASYMM map 16490 .quant8AsymmOperands = {}, 16491 // int -> QUANT16_SYMM map 16492 .quant16SymmOperands = {}, 16493 // int -> FLOAT16 map 16494 .float16Operands = {}, 16495 // int -> BOOL8 map 16496 .bool8Operands = {}, 16497 // int -> QUANT8_SYMM_PER_CHANNEL map 16498 .quant8ChannelOperands = {}, 16499 // int -> QUANT16_ASYMM map 16500 .quant16AsymmOperands = {}, 16501 // int -> QUANT8_SYMM map 16502 .quant8SymmOperands = {}, 16503 }, 16504 //Output(s) 16505 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16506 // int -> Dimensions map 16507 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16508 // int -> FLOAT32 map 16509 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16510 // int -> INT32 map 16511 .int32Operands = {}, 16512 // int -> QUANT8_ASYMM map 16513 .quant8AsymmOperands = {}, 16514 // int -> QUANT16_SYMM map 16515 .quant16SymmOperands = {}, 16516 // int -> FLOAT16 map 16517 .float16Operands = {}, 16518 // int -> BOOL8 map 16519 .bool8Operands = {}, 16520 // int -> QUANT8_SYMM_PER_CHANNEL map 16521 .quant8ChannelOperands = {}, 16522 // int -> QUANT16_ASYMM map 16523 .quant16AsymmOperands = {}, 16524 // int -> QUANT8_SYMM map 16525 .quant8SymmOperands = {}, 16526 } 16527 }, 16528 }, // End of an example 16529 }; 16530 return examples_dynamic_output_shape_nchw_weight_as_input_2; 16531 }; 16532 16533 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_2() { 16534 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_2 = { 16535 // Begin of an example 16536 { 16537 .operands = { 16538 //Input(s) 16539 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16540 // int -> Dimensions map 16541 .operandDimensions = {{0, {1, 2, 4, 4}}}, 16542 // int -> FLOAT32 map 16543 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 16544 // int -> INT32 map 16545 .int32Operands = {}, 16546 // int -> QUANT8_ASYMM map 16547 .quant8AsymmOperands = {}, 16548 // int -> QUANT16_SYMM map 16549 .quant16SymmOperands = {}, 16550 // int -> FLOAT16 map 16551 .float16Operands = {}, 16552 // int -> BOOL8 map 16553 .bool8Operands = {}, 16554 // int -> QUANT8_SYMM_PER_CHANNEL map 16555 .quant8ChannelOperands = {}, 16556 // int -> QUANT16_ASYMM map 16557 .quant16AsymmOperands = {}, 16558 // int -> QUANT8_SYMM map 16559 .quant8SymmOperands = {}, 16560 }, 16561 //Output(s) 16562 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16563 // int -> Dimensions map 16564 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16565 // int -> FLOAT32 map 16566 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16567 // int -> INT32 map 16568 .int32Operands = {}, 16569 // int -> QUANT8_ASYMM map 16570 .quant8AsymmOperands = {}, 16571 // int -> QUANT16_SYMM map 16572 .quant16SymmOperands = {}, 16573 // int -> FLOAT16 map 16574 .float16Operands = {}, 16575 // int -> BOOL8 map 16576 .bool8Operands = {}, 16577 // int -> QUANT8_SYMM_PER_CHANNEL map 16578 .quant8ChannelOperands = {}, 16579 // int -> QUANT16_ASYMM map 16580 .quant16AsymmOperands = {}, 16581 // int -> QUANT8_SYMM map 16582 .quant8SymmOperands = {}, 16583 } 16584 }, 16585 }, // End of an example 16586 }; 16587 return examples_dynamic_output_shape_nchw_relaxed_2; 16588 }; 16589 16590 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_weight_as_input_2() { 16591 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_weight_as_input_2 = { 16592 // Begin of an example 16593 { 16594 .operands = { 16595 //Input(s) 16596 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16597 // int -> Dimensions map 16598 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16599 // int -> FLOAT32 map 16600 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16601 // int -> INT32 map 16602 .int32Operands = {}, 16603 // int -> QUANT8_ASYMM map 16604 .quant8AsymmOperands = {}, 16605 // int -> QUANT16_SYMM map 16606 .quant16SymmOperands = {}, 16607 // int -> FLOAT16 map 16608 .float16Operands = {}, 16609 // int -> BOOL8 map 16610 .bool8Operands = {}, 16611 // int -> QUANT8_SYMM_PER_CHANNEL map 16612 .quant8ChannelOperands = {}, 16613 // int -> QUANT16_ASYMM map 16614 .quant16AsymmOperands = {}, 16615 // int -> QUANT8_SYMM map 16616 .quant8SymmOperands = {}, 16617 }, 16618 //Output(s) 16619 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16620 // int -> Dimensions map 16621 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16622 // int -> FLOAT32 map 16623 .float32Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16624 // int -> INT32 map 16625 .int32Operands = {}, 16626 // int -> QUANT8_ASYMM map 16627 .quant8AsymmOperands = {}, 16628 // int -> QUANT16_SYMM map 16629 .quant16SymmOperands = {}, 16630 // int -> FLOAT16 map 16631 .float16Operands = {}, 16632 // int -> BOOL8 map 16633 .bool8Operands = {}, 16634 // int -> QUANT8_SYMM_PER_CHANNEL map 16635 .quant8ChannelOperands = {}, 16636 // int -> QUANT16_ASYMM map 16637 .quant16AsymmOperands = {}, 16638 // int -> QUANT8_SYMM map 16639 .quant8SymmOperands = {}, 16640 } 16641 }, 16642 }, // End of an example 16643 }; 16644 return examples_dynamic_output_shape_nchw_relaxed_weight_as_input_2; 16645 }; 16646 16647 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_2() { 16648 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_2 = { 16649 // Begin of an example 16650 { 16651 .operands = { 16652 //Input(s) 16653 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16654 // int -> Dimensions map 16655 .operandDimensions = {{0, {1, 2, 4, 4}}}, 16656 // int -> FLOAT32 map 16657 .float32Operands = {}, 16658 // int -> INT32 map 16659 .int32Operands = {}, 16660 // int -> QUANT8_ASYMM map 16661 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 16662 // int -> QUANT16_SYMM map 16663 .quant16SymmOperands = {}, 16664 // int -> FLOAT16 map 16665 .float16Operands = {}, 16666 // int -> BOOL8 map 16667 .bool8Operands = {}, 16668 // int -> QUANT8_SYMM_PER_CHANNEL map 16669 .quant8ChannelOperands = {}, 16670 // int -> QUANT16_ASYMM map 16671 .quant16AsymmOperands = {}, 16672 // int -> QUANT8_SYMM map 16673 .quant8SymmOperands = {}, 16674 }, 16675 //Output(s) 16676 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16677 // int -> Dimensions map 16678 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16679 // int -> FLOAT32 map 16680 .float32Operands = {}, 16681 // int -> INT32 map 16682 .int32Operands = {}, 16683 // int -> QUANT8_ASYMM map 16684 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 16685 // int -> QUANT16_SYMM map 16686 .quant16SymmOperands = {}, 16687 // int -> FLOAT16 map 16688 .float16Operands = {}, 16689 // int -> BOOL8 map 16690 .bool8Operands = {}, 16691 // int -> QUANT8_SYMM_PER_CHANNEL map 16692 .quant8ChannelOperands = {}, 16693 // int -> QUANT16_ASYMM map 16694 .quant16AsymmOperands = {}, 16695 // int -> QUANT8_SYMM map 16696 .quant8SymmOperands = {}, 16697 } 16698 }, 16699 }, // End of an example 16700 }; 16701 return examples_dynamic_output_shape_nchw_quant8_2; 16702 }; 16703 16704 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_weight_as_input_2() { 16705 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_weight_as_input_2 = { 16706 // Begin of an example 16707 { 16708 .operands = { 16709 //Input(s) 16710 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16711 // int -> Dimensions map 16712 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16713 // int -> FLOAT32 map 16714 .float32Operands = {}, 16715 // int -> INT32 map 16716 .int32Operands = {{2, {0}}}, 16717 // int -> QUANT8_ASYMM map 16718 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 16719 // int -> QUANT16_SYMM map 16720 .quant16SymmOperands = {}, 16721 // int -> FLOAT16 map 16722 .float16Operands = {}, 16723 // int -> BOOL8 map 16724 .bool8Operands = {}, 16725 // int -> QUANT8_SYMM_PER_CHANNEL map 16726 .quant8ChannelOperands = {}, 16727 // int -> QUANT16_ASYMM map 16728 .quant16AsymmOperands = {}, 16729 // int -> QUANT8_SYMM map 16730 .quant8SymmOperands = {}, 16731 }, 16732 //Output(s) 16733 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16734 // int -> Dimensions map 16735 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16736 // int -> FLOAT32 map 16737 .float32Operands = {}, 16738 // int -> INT32 map 16739 .int32Operands = {}, 16740 // int -> QUANT8_ASYMM map 16741 .quant8AsymmOperands = {{0, {12, 26, 36, 33, 42, 84, 106, 90, 93, 170, 191, 153, 123, 210, 228, 172}}}, 16742 // int -> QUANT16_SYMM map 16743 .quant16SymmOperands = {}, 16744 // int -> FLOAT16 map 16745 .float16Operands = {}, 16746 // int -> BOOL8 map 16747 .bool8Operands = {}, 16748 // int -> QUANT8_SYMM_PER_CHANNEL map 16749 .quant8ChannelOperands = {}, 16750 // int -> QUANT16_ASYMM map 16751 .quant16AsymmOperands = {}, 16752 // int -> QUANT8_SYMM map 16753 .quant8SymmOperands = {}, 16754 } 16755 }, 16756 }, // End of an example 16757 }; 16758 return examples_dynamic_output_shape_nchw_quant8_weight_as_input_2; 16759 }; 16760 16761 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_2() { 16762 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_2 = { 16763 // Begin of an example 16764 { 16765 .operands = { 16766 //Input(s) 16767 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16768 // int -> Dimensions map 16769 .operandDimensions = {{0, {1, 2, 4, 4}}}, 16770 // int -> FLOAT32 map 16771 .float32Operands = {}, 16772 // int -> INT32 map 16773 .int32Operands = {}, 16774 // int -> QUANT8_ASYMM map 16775 .quant8AsymmOperands = {}, 16776 // int -> QUANT16_SYMM map 16777 .quant16SymmOperands = {}, 16778 // int -> FLOAT16 map 16779 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 16780 // int -> BOOL8 map 16781 .bool8Operands = {}, 16782 // int -> QUANT8_SYMM_PER_CHANNEL map 16783 .quant8ChannelOperands = {}, 16784 // int -> QUANT16_ASYMM map 16785 .quant16AsymmOperands = {}, 16786 // int -> QUANT8_SYMM map 16787 .quant8SymmOperands = {}, 16788 }, 16789 //Output(s) 16790 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16791 // int -> Dimensions map 16792 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16793 // int -> FLOAT32 map 16794 .float32Operands = {}, 16795 // int -> INT32 map 16796 .int32Operands = {}, 16797 // int -> QUANT8_ASYMM map 16798 .quant8AsymmOperands = {}, 16799 // int -> QUANT16_SYMM map 16800 .quant16SymmOperands = {}, 16801 // int -> FLOAT16 map 16802 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16803 // int -> BOOL8 map 16804 .bool8Operands = {}, 16805 // int -> QUANT8_SYMM_PER_CHANNEL map 16806 .quant8ChannelOperands = {}, 16807 // int -> QUANT16_ASYMM map 16808 .quant16AsymmOperands = {}, 16809 // int -> QUANT8_SYMM map 16810 .quant8SymmOperands = {}, 16811 } 16812 }, 16813 }, // End of an example 16814 }; 16815 return examples_dynamic_output_shape_nchw_float16_2; 16816 }; 16817 16818 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_weight_as_input_2() { 16819 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_weight_as_input_2 = { 16820 // Begin of an example 16821 { 16822 .operands = { 16823 //Input(s) 16824 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16825 // int -> Dimensions map 16826 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16827 // int -> FLOAT32 map 16828 .float32Operands = {}, 16829 // int -> INT32 map 16830 .int32Operands = {}, 16831 // int -> QUANT8_ASYMM map 16832 .quant8AsymmOperands = {}, 16833 // int -> QUANT16_SYMM map 16834 .quant16SymmOperands = {}, 16835 // int -> FLOAT16 map 16836 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16837 // int -> BOOL8 map 16838 .bool8Operands = {}, 16839 // int -> QUANT8_SYMM_PER_CHANNEL map 16840 .quant8ChannelOperands = {}, 16841 // int -> QUANT16_ASYMM map 16842 .quant16AsymmOperands = {}, 16843 // int -> QUANT8_SYMM map 16844 .quant8SymmOperands = {}, 16845 }, 16846 //Output(s) 16847 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16848 // int -> Dimensions map 16849 .operandDimensions = {{0, {1, 1, 4, 4}}}, 16850 // int -> FLOAT32 map 16851 .float32Operands = {}, 16852 // int -> INT32 map 16853 .int32Operands = {}, 16854 // int -> QUANT8_ASYMM map 16855 .quant8AsymmOperands = {}, 16856 // int -> QUANT16_SYMM map 16857 .quant16SymmOperands = {}, 16858 // int -> FLOAT16 map 16859 .float16Operands = {{0, {184.0f, 412.0f, 568.0f, 528.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f}}}, 16860 // int -> BOOL8 map 16861 .bool8Operands = {}, 16862 // int -> QUANT8_SYMM_PER_CHANNEL map 16863 .quant8ChannelOperands = {}, 16864 // int -> QUANT16_ASYMM map 16865 .quant16AsymmOperands = {}, 16866 // int -> QUANT8_SYMM map 16867 .quant8SymmOperands = {}, 16868 } 16869 }, 16870 }, // End of an example 16871 }; 16872 return examples_dynamic_output_shape_nchw_float16_weight_as_input_2; 16873 }; 16874 16875 std::vector<MixedTypedExample>& get_examples_nhwc_3() { 16876 static std::vector<MixedTypedExample> examples_nhwc_3 = { 16877 // Begin of an example 16878 { 16879 .operands = { 16880 //Input(s) 16881 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16882 // int -> Dimensions map 16883 .operandDimensions = {{0, {1, 4, 4, 2}}}, 16884 // int -> FLOAT32 map 16885 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 16886 // int -> INT32 map 16887 .int32Operands = {}, 16888 // int -> QUANT8_ASYMM map 16889 .quant8AsymmOperands = {}, 16890 // int -> QUANT16_SYMM map 16891 .quant16SymmOperands = {}, 16892 // int -> FLOAT16 map 16893 .float16Operands = {}, 16894 // int -> BOOL8 map 16895 .bool8Operands = {}, 16896 // int -> QUANT8_SYMM_PER_CHANNEL map 16897 .quant8ChannelOperands = {}, 16898 // int -> QUANT16_ASYMM map 16899 .quant16AsymmOperands = {}, 16900 // int -> QUANT8_SYMM map 16901 .quant8SymmOperands = {}, 16902 }, 16903 //Output(s) 16904 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16905 // int -> Dimensions map 16906 .operandDimensions = {{0, {1, 6, 6, 1}}}, 16907 // int -> FLOAT32 map 16908 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 16909 // int -> INT32 map 16910 .int32Operands = {}, 16911 // int -> QUANT8_ASYMM map 16912 .quant8AsymmOperands = {}, 16913 // int -> QUANT16_SYMM map 16914 .quant16SymmOperands = {}, 16915 // int -> FLOAT16 map 16916 .float16Operands = {}, 16917 // int -> BOOL8 map 16918 .bool8Operands = {}, 16919 // int -> QUANT8_SYMM_PER_CHANNEL map 16920 .quant8ChannelOperands = {}, 16921 // int -> QUANT16_ASYMM map 16922 .quant16AsymmOperands = {}, 16923 // int -> QUANT8_SYMM map 16924 .quant8SymmOperands = {}, 16925 } 16926 }, 16927 }, // End of an example 16928 }; 16929 return examples_nhwc_3; 16930 }; 16931 16932 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_3() { 16933 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_3 = { 16934 // Begin of an example 16935 { 16936 .operands = { 16937 //Input(s) 16938 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16939 // int -> Dimensions map 16940 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 16941 // int -> FLOAT32 map 16942 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 16943 // int -> INT32 map 16944 .int32Operands = {}, 16945 // int -> QUANT8_ASYMM map 16946 .quant8AsymmOperands = {}, 16947 // int -> QUANT16_SYMM map 16948 .quant16SymmOperands = {}, 16949 // int -> FLOAT16 map 16950 .float16Operands = {}, 16951 // int -> BOOL8 map 16952 .bool8Operands = {}, 16953 // int -> QUANT8_SYMM_PER_CHANNEL map 16954 .quant8ChannelOperands = {}, 16955 // int -> QUANT16_ASYMM map 16956 .quant16AsymmOperands = {}, 16957 // int -> QUANT8_SYMM map 16958 .quant8SymmOperands = {}, 16959 }, 16960 //Output(s) 16961 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16962 // int -> Dimensions map 16963 .operandDimensions = {{0, {1, 6, 6, 1}}}, 16964 // int -> FLOAT32 map 16965 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 16966 // int -> INT32 map 16967 .int32Operands = {}, 16968 // int -> QUANT8_ASYMM map 16969 .quant8AsymmOperands = {}, 16970 // int -> QUANT16_SYMM map 16971 .quant16SymmOperands = {}, 16972 // int -> FLOAT16 map 16973 .float16Operands = {}, 16974 // int -> BOOL8 map 16975 .bool8Operands = {}, 16976 // int -> QUANT8_SYMM_PER_CHANNEL map 16977 .quant8ChannelOperands = {}, 16978 // int -> QUANT16_ASYMM map 16979 .quant16AsymmOperands = {}, 16980 // int -> QUANT8_SYMM map 16981 .quant8SymmOperands = {}, 16982 } 16983 }, 16984 }, // End of an example 16985 }; 16986 return examples_nhwc_weight_as_input_3; 16987 }; 16988 16989 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_3() { 16990 static std::vector<MixedTypedExample> examples_nhwc_relaxed_3 = { 16991 // Begin of an example 16992 { 16993 .operands = { 16994 //Input(s) 16995 { // See tools/test_generator/include/TestHarness.h:MixedTyped 16996 // int -> Dimensions map 16997 .operandDimensions = {{0, {1, 4, 4, 2}}}, 16998 // int -> FLOAT32 map 16999 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 17000 // int -> INT32 map 17001 .int32Operands = {}, 17002 // int -> QUANT8_ASYMM map 17003 .quant8AsymmOperands = {}, 17004 // int -> QUANT16_SYMM map 17005 .quant16SymmOperands = {}, 17006 // int -> FLOAT16 map 17007 .float16Operands = {}, 17008 // int -> BOOL8 map 17009 .bool8Operands = {}, 17010 // int -> QUANT8_SYMM_PER_CHANNEL map 17011 .quant8ChannelOperands = {}, 17012 // int -> QUANT16_ASYMM map 17013 .quant16AsymmOperands = {}, 17014 // int -> QUANT8_SYMM map 17015 .quant8SymmOperands = {}, 17016 }, 17017 //Output(s) 17018 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17019 // int -> Dimensions map 17020 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17021 // int -> FLOAT32 map 17022 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17023 // int -> INT32 map 17024 .int32Operands = {}, 17025 // int -> QUANT8_ASYMM map 17026 .quant8AsymmOperands = {}, 17027 // int -> QUANT16_SYMM map 17028 .quant16SymmOperands = {}, 17029 // int -> FLOAT16 map 17030 .float16Operands = {}, 17031 // int -> BOOL8 map 17032 .bool8Operands = {}, 17033 // int -> QUANT8_SYMM_PER_CHANNEL map 17034 .quant8ChannelOperands = {}, 17035 // int -> QUANT16_ASYMM map 17036 .quant16AsymmOperands = {}, 17037 // int -> QUANT8_SYMM map 17038 .quant8SymmOperands = {}, 17039 } 17040 }, 17041 }, // End of an example 17042 }; 17043 return examples_nhwc_relaxed_3; 17044 }; 17045 17046 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_weight_as_input_3() { 17047 static std::vector<MixedTypedExample> examples_nhwc_relaxed_weight_as_input_3 = { 17048 // Begin of an example 17049 { 17050 .operands = { 17051 //Input(s) 17052 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17053 // int -> Dimensions map 17054 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17055 // int -> FLOAT32 map 17056 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17057 // int -> INT32 map 17058 .int32Operands = {}, 17059 // int -> QUANT8_ASYMM map 17060 .quant8AsymmOperands = {}, 17061 // int -> QUANT16_SYMM map 17062 .quant16SymmOperands = {}, 17063 // int -> FLOAT16 map 17064 .float16Operands = {}, 17065 // int -> BOOL8 map 17066 .bool8Operands = {}, 17067 // int -> QUANT8_SYMM_PER_CHANNEL map 17068 .quant8ChannelOperands = {}, 17069 // int -> QUANT16_ASYMM map 17070 .quant16AsymmOperands = {}, 17071 // int -> QUANT8_SYMM map 17072 .quant8SymmOperands = {}, 17073 }, 17074 //Output(s) 17075 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17076 // int -> Dimensions map 17077 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17078 // int -> FLOAT32 map 17079 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17080 // int -> INT32 map 17081 .int32Operands = {}, 17082 // int -> QUANT8_ASYMM map 17083 .quant8AsymmOperands = {}, 17084 // int -> QUANT16_SYMM map 17085 .quant16SymmOperands = {}, 17086 // int -> FLOAT16 map 17087 .float16Operands = {}, 17088 // int -> BOOL8 map 17089 .bool8Operands = {}, 17090 // int -> QUANT8_SYMM_PER_CHANNEL map 17091 .quant8ChannelOperands = {}, 17092 // int -> QUANT16_ASYMM map 17093 .quant16AsymmOperands = {}, 17094 // int -> QUANT8_SYMM map 17095 .quant8SymmOperands = {}, 17096 } 17097 }, 17098 }, // End of an example 17099 }; 17100 return examples_nhwc_relaxed_weight_as_input_3; 17101 }; 17102 17103 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_3() { 17104 static std::vector<MixedTypedExample> examples_nhwc_quant8_3 = { 17105 // Begin of an example 17106 { 17107 .operands = { 17108 //Input(s) 17109 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17110 // int -> Dimensions map 17111 .operandDimensions = {{0, {1, 4, 4, 2}}}, 17112 // int -> FLOAT32 map 17113 .float32Operands = {}, 17114 // int -> INT32 map 17115 .int32Operands = {}, 17116 // int -> QUANT8_ASYMM map 17117 .quant8AsymmOperands = {{0, {14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138}}}, 17118 // int -> QUANT16_SYMM map 17119 .quant16SymmOperands = {}, 17120 // int -> FLOAT16 map 17121 .float16Operands = {}, 17122 // int -> BOOL8 map 17123 .bool8Operands = {}, 17124 // int -> QUANT8_SYMM_PER_CHANNEL map 17125 .quant8ChannelOperands = {}, 17126 // int -> QUANT16_ASYMM map 17127 .quant16AsymmOperands = {}, 17128 // int -> QUANT8_SYMM map 17129 .quant8SymmOperands = {}, 17130 }, 17131 //Output(s) 17132 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17133 // int -> Dimensions map 17134 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17135 // int -> FLOAT32 map 17136 .float32Operands = {}, 17137 // int -> INT32 map 17138 .int32Operands = {}, 17139 // int -> QUANT8_ASYMM map 17140 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 17141 // int -> QUANT16_SYMM map 17142 .quant16SymmOperands = {}, 17143 // int -> FLOAT16 map 17144 .float16Operands = {}, 17145 // int -> BOOL8 map 17146 .bool8Operands = {}, 17147 // int -> QUANT8_SYMM_PER_CHANNEL map 17148 .quant8ChannelOperands = {}, 17149 // int -> QUANT16_ASYMM map 17150 .quant16AsymmOperands = {}, 17151 // int -> QUANT8_SYMM map 17152 .quant8SymmOperands = {}, 17153 } 17154 }, 17155 }, // End of an example 17156 }; 17157 return examples_nhwc_quant8_3; 17158 }; 17159 17160 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_weight_as_input_3() { 17161 static std::vector<MixedTypedExample> examples_nhwc_quant8_weight_as_input_3 = { 17162 // Begin of an example 17163 { 17164 .operands = { 17165 //Input(s) 17166 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17167 // int -> Dimensions map 17168 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17169 // int -> FLOAT32 map 17170 .float32Operands = {}, 17171 // int -> INT32 map 17172 .int32Operands = {{2, {0}}}, 17173 // int -> QUANT8_ASYMM map 17174 .quant8AsymmOperands = {{0, {14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 17175 // int -> QUANT16_SYMM map 17176 .quant16SymmOperands = {}, 17177 // int -> FLOAT16 map 17178 .float16Operands = {}, 17179 // int -> BOOL8 map 17180 .bool8Operands = {}, 17181 // int -> QUANT8_SYMM_PER_CHANNEL map 17182 .quant8ChannelOperands = {}, 17183 // int -> QUANT16_ASYMM map 17184 .quant16AsymmOperands = {}, 17185 // int -> QUANT8_SYMM map 17186 .quant8SymmOperands = {}, 17187 }, 17188 //Output(s) 17189 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17190 // int -> Dimensions map 17191 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17192 // int -> FLOAT32 map 17193 .float32Operands = {}, 17194 // int -> INT32 map 17195 .int32Operands = {}, 17196 // int -> QUANT8_ASYMM map 17197 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 17198 // int -> QUANT16_SYMM map 17199 .quant16SymmOperands = {}, 17200 // int -> FLOAT16 map 17201 .float16Operands = {}, 17202 // int -> BOOL8 map 17203 .bool8Operands = {}, 17204 // int -> QUANT8_SYMM_PER_CHANNEL map 17205 .quant8ChannelOperands = {}, 17206 // int -> QUANT16_ASYMM map 17207 .quant16AsymmOperands = {}, 17208 // int -> QUANT8_SYMM map 17209 .quant8SymmOperands = {}, 17210 } 17211 }, 17212 }, // End of an example 17213 }; 17214 return examples_nhwc_quant8_weight_as_input_3; 17215 }; 17216 17217 std::vector<MixedTypedExample>& get_examples_nhwc_float16_3() { 17218 static std::vector<MixedTypedExample> examples_nhwc_float16_3 = { 17219 // Begin of an example 17220 { 17221 .operands = { 17222 //Input(s) 17223 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17224 // int -> Dimensions map 17225 .operandDimensions = {{0, {1, 4, 4, 2}}}, 17226 // int -> FLOAT32 map 17227 .float32Operands = {}, 17228 // int -> INT32 map 17229 .int32Operands = {}, 17230 // int -> QUANT8_ASYMM map 17231 .quant8AsymmOperands = {}, 17232 // int -> QUANT16_SYMM map 17233 .quant16SymmOperands = {}, 17234 // int -> FLOAT16 map 17235 .float16Operands = {{0, {1.0f, 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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 17236 // int -> BOOL8 map 17237 .bool8Operands = {}, 17238 // int -> QUANT8_SYMM_PER_CHANNEL map 17239 .quant8ChannelOperands = {}, 17240 // int -> QUANT16_ASYMM map 17241 .quant16AsymmOperands = {}, 17242 // int -> QUANT8_SYMM map 17243 .quant8SymmOperands = {}, 17244 }, 17245 //Output(s) 17246 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17247 // int -> Dimensions map 17248 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17249 // int -> FLOAT32 map 17250 .float32Operands = {}, 17251 // int -> INT32 map 17252 .int32Operands = {}, 17253 // int -> QUANT8_ASYMM map 17254 .quant8AsymmOperands = {}, 17255 // int -> QUANT16_SYMM map 17256 .quant16SymmOperands = {}, 17257 // int -> FLOAT16 map 17258 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17259 // int -> BOOL8 map 17260 .bool8Operands = {}, 17261 // int -> QUANT8_SYMM_PER_CHANNEL map 17262 .quant8ChannelOperands = {}, 17263 // int -> QUANT16_ASYMM map 17264 .quant16AsymmOperands = {}, 17265 // int -> QUANT8_SYMM map 17266 .quant8SymmOperands = {}, 17267 } 17268 }, 17269 }, // End of an example 17270 }; 17271 return examples_nhwc_float16_3; 17272 }; 17273 17274 std::vector<MixedTypedExample>& get_examples_nhwc_float16_weight_as_input_3() { 17275 static std::vector<MixedTypedExample> examples_nhwc_float16_weight_as_input_3 = { 17276 // Begin of an example 17277 { 17278 .operands = { 17279 //Input(s) 17280 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17281 // int -> Dimensions map 17282 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17283 // int -> FLOAT32 map 17284 .float32Operands = {}, 17285 // int -> INT32 map 17286 .int32Operands = {}, 17287 // int -> QUANT8_ASYMM map 17288 .quant8AsymmOperands = {}, 17289 // int -> QUANT16_SYMM map 17290 .quant16SymmOperands = {}, 17291 // int -> FLOAT16 map 17292 .float16Operands = {{0, {1.0f, 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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17293 // int -> BOOL8 map 17294 .bool8Operands = {}, 17295 // int -> QUANT8_SYMM_PER_CHANNEL map 17296 .quant8ChannelOperands = {}, 17297 // int -> QUANT16_ASYMM map 17298 .quant16AsymmOperands = {}, 17299 // int -> QUANT8_SYMM map 17300 .quant8SymmOperands = {}, 17301 }, 17302 //Output(s) 17303 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17304 // int -> Dimensions map 17305 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17306 // int -> FLOAT32 map 17307 .float32Operands = {}, 17308 // int -> INT32 map 17309 .int32Operands = {}, 17310 // int -> QUANT8_ASYMM map 17311 .quant8AsymmOperands = {}, 17312 // int -> QUANT16_SYMM map 17313 .quant16SymmOperands = {}, 17314 // int -> FLOAT16 map 17315 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17316 // int -> BOOL8 map 17317 .bool8Operands = {}, 17318 // int -> QUANT8_SYMM_PER_CHANNEL map 17319 .quant8ChannelOperands = {}, 17320 // int -> QUANT16_ASYMM map 17321 .quant16AsymmOperands = {}, 17322 // int -> QUANT8_SYMM map 17323 .quant8SymmOperands = {}, 17324 } 17325 }, 17326 }, // End of an example 17327 }; 17328 return examples_nhwc_float16_weight_as_input_3; 17329 }; 17330 17331 std::vector<MixedTypedExample>& get_examples_nchw_3() { 17332 static std::vector<MixedTypedExample> examples_nchw_3 = { 17333 // Begin of an example 17334 { 17335 .operands = { 17336 //Input(s) 17337 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17338 // int -> Dimensions map 17339 .operandDimensions = {{0, {1, 2, 4, 4}}}, 17340 // int -> FLOAT32 map 17341 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 17342 // int -> INT32 map 17343 .int32Operands = {}, 17344 // int -> QUANT8_ASYMM map 17345 .quant8AsymmOperands = {}, 17346 // int -> QUANT16_SYMM map 17347 .quant16SymmOperands = {}, 17348 // int -> FLOAT16 map 17349 .float16Operands = {}, 17350 // int -> BOOL8 map 17351 .bool8Operands = {}, 17352 // int -> QUANT8_SYMM_PER_CHANNEL map 17353 .quant8ChannelOperands = {}, 17354 // int -> QUANT16_ASYMM map 17355 .quant16AsymmOperands = {}, 17356 // int -> QUANT8_SYMM map 17357 .quant8SymmOperands = {}, 17358 }, 17359 //Output(s) 17360 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17361 // int -> Dimensions map 17362 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17363 // int -> FLOAT32 map 17364 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17365 // int -> INT32 map 17366 .int32Operands = {}, 17367 // int -> QUANT8_ASYMM map 17368 .quant8AsymmOperands = {}, 17369 // int -> QUANT16_SYMM map 17370 .quant16SymmOperands = {}, 17371 // int -> FLOAT16 map 17372 .float16Operands = {}, 17373 // int -> BOOL8 map 17374 .bool8Operands = {}, 17375 // int -> QUANT8_SYMM_PER_CHANNEL map 17376 .quant8ChannelOperands = {}, 17377 // int -> QUANT16_ASYMM map 17378 .quant16AsymmOperands = {}, 17379 // int -> QUANT8_SYMM map 17380 .quant8SymmOperands = {}, 17381 } 17382 }, 17383 }, // End of an example 17384 }; 17385 return examples_nchw_3; 17386 }; 17387 17388 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_3() { 17389 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_3 = { 17390 // Begin of an example 17391 { 17392 .operands = { 17393 //Input(s) 17394 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17395 // int -> Dimensions map 17396 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17397 // int -> FLOAT32 map 17398 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17399 // int -> INT32 map 17400 .int32Operands = {}, 17401 // int -> QUANT8_ASYMM map 17402 .quant8AsymmOperands = {}, 17403 // int -> QUANT16_SYMM map 17404 .quant16SymmOperands = {}, 17405 // int -> FLOAT16 map 17406 .float16Operands = {}, 17407 // int -> BOOL8 map 17408 .bool8Operands = {}, 17409 // int -> QUANT8_SYMM_PER_CHANNEL map 17410 .quant8ChannelOperands = {}, 17411 // int -> QUANT16_ASYMM map 17412 .quant16AsymmOperands = {}, 17413 // int -> QUANT8_SYMM map 17414 .quant8SymmOperands = {}, 17415 }, 17416 //Output(s) 17417 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17418 // int -> Dimensions map 17419 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17420 // int -> FLOAT32 map 17421 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17422 // int -> INT32 map 17423 .int32Operands = {}, 17424 // int -> QUANT8_ASYMM map 17425 .quant8AsymmOperands = {}, 17426 // int -> QUANT16_SYMM map 17427 .quant16SymmOperands = {}, 17428 // int -> FLOAT16 map 17429 .float16Operands = {}, 17430 // int -> BOOL8 map 17431 .bool8Operands = {}, 17432 // int -> QUANT8_SYMM_PER_CHANNEL map 17433 .quant8ChannelOperands = {}, 17434 // int -> QUANT16_ASYMM map 17435 .quant16AsymmOperands = {}, 17436 // int -> QUANT8_SYMM map 17437 .quant8SymmOperands = {}, 17438 } 17439 }, 17440 }, // End of an example 17441 }; 17442 return examples_nchw_weight_as_input_3; 17443 }; 17444 17445 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_3() { 17446 static std::vector<MixedTypedExample> examples_nchw_relaxed_3 = { 17447 // Begin of an example 17448 { 17449 .operands = { 17450 //Input(s) 17451 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17452 // int -> Dimensions map 17453 .operandDimensions = {{0, {1, 2, 4, 4}}}, 17454 // int -> FLOAT32 map 17455 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 17456 // int -> INT32 map 17457 .int32Operands = {}, 17458 // int -> QUANT8_ASYMM map 17459 .quant8AsymmOperands = {}, 17460 // int -> QUANT16_SYMM map 17461 .quant16SymmOperands = {}, 17462 // int -> FLOAT16 map 17463 .float16Operands = {}, 17464 // int -> BOOL8 map 17465 .bool8Operands = {}, 17466 // int -> QUANT8_SYMM_PER_CHANNEL map 17467 .quant8ChannelOperands = {}, 17468 // int -> QUANT16_ASYMM map 17469 .quant16AsymmOperands = {}, 17470 // int -> QUANT8_SYMM map 17471 .quant8SymmOperands = {}, 17472 }, 17473 //Output(s) 17474 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17475 // int -> Dimensions map 17476 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17477 // int -> FLOAT32 map 17478 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17479 // int -> INT32 map 17480 .int32Operands = {}, 17481 // int -> QUANT8_ASYMM map 17482 .quant8AsymmOperands = {}, 17483 // int -> QUANT16_SYMM map 17484 .quant16SymmOperands = {}, 17485 // int -> FLOAT16 map 17486 .float16Operands = {}, 17487 // int -> BOOL8 map 17488 .bool8Operands = {}, 17489 // int -> QUANT8_SYMM_PER_CHANNEL map 17490 .quant8ChannelOperands = {}, 17491 // int -> QUANT16_ASYMM map 17492 .quant16AsymmOperands = {}, 17493 // int -> QUANT8_SYMM map 17494 .quant8SymmOperands = {}, 17495 } 17496 }, 17497 }, // End of an example 17498 }; 17499 return examples_nchw_relaxed_3; 17500 }; 17501 17502 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_weight_as_input_3() { 17503 static std::vector<MixedTypedExample> examples_nchw_relaxed_weight_as_input_3 = { 17504 // Begin of an example 17505 { 17506 .operands = { 17507 //Input(s) 17508 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17509 // int -> Dimensions map 17510 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17511 // int -> FLOAT32 map 17512 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17513 // int -> INT32 map 17514 .int32Operands = {}, 17515 // int -> QUANT8_ASYMM map 17516 .quant8AsymmOperands = {}, 17517 // int -> QUANT16_SYMM map 17518 .quant16SymmOperands = {}, 17519 // int -> FLOAT16 map 17520 .float16Operands = {}, 17521 // int -> BOOL8 map 17522 .bool8Operands = {}, 17523 // int -> QUANT8_SYMM_PER_CHANNEL map 17524 .quant8ChannelOperands = {}, 17525 // int -> QUANT16_ASYMM map 17526 .quant16AsymmOperands = {}, 17527 // int -> QUANT8_SYMM map 17528 .quant8SymmOperands = {}, 17529 }, 17530 //Output(s) 17531 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17532 // int -> Dimensions map 17533 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17534 // int -> FLOAT32 map 17535 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17536 // int -> INT32 map 17537 .int32Operands = {}, 17538 // int -> QUANT8_ASYMM map 17539 .quant8AsymmOperands = {}, 17540 // int -> QUANT16_SYMM map 17541 .quant16SymmOperands = {}, 17542 // int -> FLOAT16 map 17543 .float16Operands = {}, 17544 // int -> BOOL8 map 17545 .bool8Operands = {}, 17546 // int -> QUANT8_SYMM_PER_CHANNEL map 17547 .quant8ChannelOperands = {}, 17548 // int -> QUANT16_ASYMM map 17549 .quant16AsymmOperands = {}, 17550 // int -> QUANT8_SYMM map 17551 .quant8SymmOperands = {}, 17552 } 17553 }, 17554 }, // End of an example 17555 }; 17556 return examples_nchw_relaxed_weight_as_input_3; 17557 }; 17558 17559 std::vector<MixedTypedExample>& get_examples_nchw_quant8_3() { 17560 static std::vector<MixedTypedExample> examples_nchw_quant8_3 = { 17561 // Begin of an example 17562 { 17563 .operands = { 17564 //Input(s) 17565 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17566 // int -> Dimensions map 17567 .operandDimensions = {{0, {1, 2, 4, 4}}}, 17568 // int -> FLOAT32 map 17569 .float32Operands = {}, 17570 // int -> INT32 map 17571 .int32Operands = {}, 17572 // int -> QUANT8_ASYMM map 17573 .quant8AsymmOperands = {{0, {14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, 130, 138}}}, 17574 // int -> QUANT16_SYMM map 17575 .quant16SymmOperands = {}, 17576 // int -> FLOAT16 map 17577 .float16Operands = {}, 17578 // int -> BOOL8 map 17579 .bool8Operands = {}, 17580 // int -> QUANT8_SYMM_PER_CHANNEL map 17581 .quant8ChannelOperands = {}, 17582 // int -> QUANT16_ASYMM map 17583 .quant16AsymmOperands = {}, 17584 // int -> QUANT8_SYMM map 17585 .quant8SymmOperands = {}, 17586 }, 17587 //Output(s) 17588 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17589 // int -> Dimensions map 17590 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17591 // int -> FLOAT32 map 17592 .float32Operands = {}, 17593 // int -> INT32 map 17594 .int32Operands = {}, 17595 // int -> QUANT8_ASYMM map 17596 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 17597 // int -> QUANT16_SYMM map 17598 .quant16SymmOperands = {}, 17599 // int -> FLOAT16 map 17600 .float16Operands = {}, 17601 // int -> BOOL8 map 17602 .bool8Operands = {}, 17603 // int -> QUANT8_SYMM_PER_CHANNEL map 17604 .quant8ChannelOperands = {}, 17605 // int -> QUANT16_ASYMM map 17606 .quant16AsymmOperands = {}, 17607 // int -> QUANT8_SYMM map 17608 .quant8SymmOperands = {}, 17609 } 17610 }, 17611 }, // End of an example 17612 }; 17613 return examples_nchw_quant8_3; 17614 }; 17615 17616 std::vector<MixedTypedExample>& get_examples_nchw_quant8_weight_as_input_3() { 17617 static std::vector<MixedTypedExample> examples_nchw_quant8_weight_as_input_3 = { 17618 // Begin of an example 17619 { 17620 .operands = { 17621 //Input(s) 17622 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17623 // int -> Dimensions map 17624 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17625 // int -> FLOAT32 map 17626 .float32Operands = {}, 17627 // int -> INT32 map 17628 .int32Operands = {{2, {0}}}, 17629 // int -> QUANT8_ASYMM map 17630 .quant8AsymmOperands = {{0, {14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, 130, 138}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 17631 // int -> QUANT16_SYMM map 17632 .quant16SymmOperands = {}, 17633 // int -> FLOAT16 map 17634 .float16Operands = {}, 17635 // int -> BOOL8 map 17636 .bool8Operands = {}, 17637 // int -> QUANT8_SYMM_PER_CHANNEL map 17638 .quant8ChannelOperands = {}, 17639 // int -> QUANT16_ASYMM map 17640 .quant16AsymmOperands = {}, 17641 // int -> QUANT8_SYMM map 17642 .quant8SymmOperands = {}, 17643 }, 17644 //Output(s) 17645 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17646 // int -> Dimensions map 17647 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17648 // int -> FLOAT32 map 17649 .float32Operands = {}, 17650 // int -> INT32 map 17651 .int32Operands = {}, 17652 // int -> QUANT8_ASYMM map 17653 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 17654 // int -> QUANT16_SYMM map 17655 .quant16SymmOperands = {}, 17656 // int -> FLOAT16 map 17657 .float16Operands = {}, 17658 // int -> BOOL8 map 17659 .bool8Operands = {}, 17660 // int -> QUANT8_SYMM_PER_CHANNEL map 17661 .quant8ChannelOperands = {}, 17662 // int -> QUANT16_ASYMM map 17663 .quant16AsymmOperands = {}, 17664 // int -> QUANT8_SYMM map 17665 .quant8SymmOperands = {}, 17666 } 17667 }, 17668 }, // End of an example 17669 }; 17670 return examples_nchw_quant8_weight_as_input_3; 17671 }; 17672 17673 std::vector<MixedTypedExample>& get_examples_nchw_float16_3() { 17674 static std::vector<MixedTypedExample> examples_nchw_float16_3 = { 17675 // Begin of an example 17676 { 17677 .operands = { 17678 //Input(s) 17679 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17680 // int -> Dimensions map 17681 .operandDimensions = {{0, {1, 2, 4, 4}}}, 17682 // int -> FLOAT32 map 17683 .float32Operands = {}, 17684 // int -> INT32 map 17685 .int32Operands = {}, 17686 // int -> QUANT8_ASYMM map 17687 .quant8AsymmOperands = {}, 17688 // int -> QUANT16_SYMM map 17689 .quant16SymmOperands = {}, 17690 // int -> FLOAT16 map 17691 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 17692 // int -> BOOL8 map 17693 .bool8Operands = {}, 17694 // int -> QUANT8_SYMM_PER_CHANNEL map 17695 .quant8ChannelOperands = {}, 17696 // int -> QUANT16_ASYMM map 17697 .quant16AsymmOperands = {}, 17698 // int -> QUANT8_SYMM map 17699 .quant8SymmOperands = {}, 17700 }, 17701 //Output(s) 17702 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17703 // int -> Dimensions map 17704 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17705 // int -> FLOAT32 map 17706 .float32Operands = {}, 17707 // int -> INT32 map 17708 .int32Operands = {}, 17709 // int -> QUANT8_ASYMM map 17710 .quant8AsymmOperands = {}, 17711 // int -> QUANT16_SYMM map 17712 .quant16SymmOperands = {}, 17713 // int -> FLOAT16 map 17714 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17715 // int -> BOOL8 map 17716 .bool8Operands = {}, 17717 // int -> QUANT8_SYMM_PER_CHANNEL map 17718 .quant8ChannelOperands = {}, 17719 // int -> QUANT16_ASYMM map 17720 .quant16AsymmOperands = {}, 17721 // int -> QUANT8_SYMM map 17722 .quant8SymmOperands = {}, 17723 } 17724 }, 17725 }, // End of an example 17726 }; 17727 return examples_nchw_float16_3; 17728 }; 17729 17730 std::vector<MixedTypedExample>& get_examples_nchw_float16_weight_as_input_3() { 17731 static std::vector<MixedTypedExample> examples_nchw_float16_weight_as_input_3 = { 17732 // Begin of an example 17733 { 17734 .operands = { 17735 //Input(s) 17736 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17737 // int -> Dimensions map 17738 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17739 // int -> FLOAT32 map 17740 .float32Operands = {}, 17741 // int -> INT32 map 17742 .int32Operands = {}, 17743 // int -> QUANT8_ASYMM map 17744 .quant8AsymmOperands = {}, 17745 // int -> QUANT16_SYMM map 17746 .quant16SymmOperands = {}, 17747 // int -> FLOAT16 map 17748 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17749 // int -> BOOL8 map 17750 .bool8Operands = {}, 17751 // int -> QUANT8_SYMM_PER_CHANNEL map 17752 .quant8ChannelOperands = {}, 17753 // int -> QUANT16_ASYMM map 17754 .quant16AsymmOperands = {}, 17755 // int -> QUANT8_SYMM map 17756 .quant8SymmOperands = {}, 17757 }, 17758 //Output(s) 17759 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17760 // int -> Dimensions map 17761 .operandDimensions = {{0, {1, 1, 6, 6}}}, 17762 // int -> FLOAT32 map 17763 .float32Operands = {}, 17764 // int -> INT32 map 17765 .int32Operands = {}, 17766 // int -> QUANT8_ASYMM map 17767 .quant8AsymmOperands = {}, 17768 // int -> QUANT16_SYMM map 17769 .quant16SymmOperands = {}, 17770 // int -> FLOAT16 map 17771 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17772 // int -> BOOL8 map 17773 .bool8Operands = {}, 17774 // int -> QUANT8_SYMM_PER_CHANNEL map 17775 .quant8ChannelOperands = {}, 17776 // int -> QUANT16_ASYMM map 17777 .quant16AsymmOperands = {}, 17778 // int -> QUANT8_SYMM map 17779 .quant8SymmOperands = {}, 17780 } 17781 }, 17782 }, // End of an example 17783 }; 17784 return examples_nchw_float16_weight_as_input_3; 17785 }; 17786 17787 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_3() { 17788 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_3 = { 17789 // Begin of an example 17790 { 17791 .operands = { 17792 //Input(s) 17793 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17794 // int -> Dimensions map 17795 .operandDimensions = {{0, {1, 4, 4, 2}}}, 17796 // int -> FLOAT32 map 17797 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 17798 // int -> INT32 map 17799 .int32Operands = {}, 17800 // int -> QUANT8_ASYMM map 17801 .quant8AsymmOperands = {}, 17802 // int -> QUANT16_SYMM map 17803 .quant16SymmOperands = {}, 17804 // int -> FLOAT16 map 17805 .float16Operands = {}, 17806 // int -> BOOL8 map 17807 .bool8Operands = {}, 17808 // int -> QUANT8_SYMM_PER_CHANNEL map 17809 .quant8ChannelOperands = {}, 17810 // int -> QUANT16_ASYMM map 17811 .quant16AsymmOperands = {}, 17812 // int -> QUANT8_SYMM map 17813 .quant8SymmOperands = {}, 17814 }, 17815 //Output(s) 17816 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17817 // int -> Dimensions map 17818 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17819 // int -> FLOAT32 map 17820 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17821 // int -> INT32 map 17822 .int32Operands = {}, 17823 // int -> QUANT8_ASYMM map 17824 .quant8AsymmOperands = {}, 17825 // int -> QUANT16_SYMM map 17826 .quant16SymmOperands = {}, 17827 // int -> FLOAT16 map 17828 .float16Operands = {}, 17829 // int -> BOOL8 map 17830 .bool8Operands = {}, 17831 // int -> QUANT8_SYMM_PER_CHANNEL map 17832 .quant8ChannelOperands = {}, 17833 // int -> QUANT16_ASYMM map 17834 .quant16AsymmOperands = {}, 17835 // int -> QUANT8_SYMM map 17836 .quant8SymmOperands = {}, 17837 } 17838 }, 17839 }, // End of an example 17840 }; 17841 return examples_dynamic_output_shape_nhwc_3; 17842 }; 17843 17844 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_3() { 17845 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_3 = { 17846 // Begin of an example 17847 { 17848 .operands = { 17849 //Input(s) 17850 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17851 // int -> Dimensions map 17852 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17853 // int -> FLOAT32 map 17854 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17855 // int -> INT32 map 17856 .int32Operands = {}, 17857 // int -> QUANT8_ASYMM map 17858 .quant8AsymmOperands = {}, 17859 // int -> QUANT16_SYMM map 17860 .quant16SymmOperands = {}, 17861 // int -> FLOAT16 map 17862 .float16Operands = {}, 17863 // int -> BOOL8 map 17864 .bool8Operands = {}, 17865 // int -> QUANT8_SYMM_PER_CHANNEL map 17866 .quant8ChannelOperands = {}, 17867 // int -> QUANT16_ASYMM map 17868 .quant16AsymmOperands = {}, 17869 // int -> QUANT8_SYMM map 17870 .quant8SymmOperands = {}, 17871 }, 17872 //Output(s) 17873 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17874 // int -> Dimensions map 17875 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17876 // int -> FLOAT32 map 17877 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17878 // int -> INT32 map 17879 .int32Operands = {}, 17880 // int -> QUANT8_ASYMM map 17881 .quant8AsymmOperands = {}, 17882 // int -> QUANT16_SYMM map 17883 .quant16SymmOperands = {}, 17884 // int -> FLOAT16 map 17885 .float16Operands = {}, 17886 // int -> BOOL8 map 17887 .bool8Operands = {}, 17888 // int -> QUANT8_SYMM_PER_CHANNEL map 17889 .quant8ChannelOperands = {}, 17890 // int -> QUANT16_ASYMM map 17891 .quant16AsymmOperands = {}, 17892 // int -> QUANT8_SYMM map 17893 .quant8SymmOperands = {}, 17894 } 17895 }, 17896 }, // End of an example 17897 }; 17898 return examples_dynamic_output_shape_nhwc_weight_as_input_3; 17899 }; 17900 17901 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_3() { 17902 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_3 = { 17903 // Begin of an example 17904 { 17905 .operands = { 17906 //Input(s) 17907 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17908 // int -> Dimensions map 17909 .operandDimensions = {{0, {1, 4, 4, 2}}}, 17910 // int -> FLOAT32 map 17911 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 17912 // int -> INT32 map 17913 .int32Operands = {}, 17914 // int -> QUANT8_ASYMM map 17915 .quant8AsymmOperands = {}, 17916 // int -> QUANT16_SYMM map 17917 .quant16SymmOperands = {}, 17918 // int -> FLOAT16 map 17919 .float16Operands = {}, 17920 // int -> BOOL8 map 17921 .bool8Operands = {}, 17922 // int -> QUANT8_SYMM_PER_CHANNEL map 17923 .quant8ChannelOperands = {}, 17924 // int -> QUANT16_ASYMM map 17925 .quant16AsymmOperands = {}, 17926 // int -> QUANT8_SYMM map 17927 .quant8SymmOperands = {}, 17928 }, 17929 //Output(s) 17930 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17931 // int -> Dimensions map 17932 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17933 // int -> FLOAT32 map 17934 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17935 // int -> INT32 map 17936 .int32Operands = {}, 17937 // int -> QUANT8_ASYMM map 17938 .quant8AsymmOperands = {}, 17939 // int -> QUANT16_SYMM map 17940 .quant16SymmOperands = {}, 17941 // int -> FLOAT16 map 17942 .float16Operands = {}, 17943 // int -> BOOL8 map 17944 .bool8Operands = {}, 17945 // int -> QUANT8_SYMM_PER_CHANNEL map 17946 .quant8ChannelOperands = {}, 17947 // int -> QUANT16_ASYMM map 17948 .quant16AsymmOperands = {}, 17949 // int -> QUANT8_SYMM map 17950 .quant8SymmOperands = {}, 17951 } 17952 }, 17953 }, // End of an example 17954 }; 17955 return examples_dynamic_output_shape_nhwc_relaxed_3; 17956 }; 17957 17958 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_3() { 17959 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_3 = { 17960 // Begin of an example 17961 { 17962 .operands = { 17963 //Input(s) 17964 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17965 // int -> Dimensions map 17966 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 17967 // int -> FLOAT32 map 17968 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 17969 // int -> INT32 map 17970 .int32Operands = {}, 17971 // int -> QUANT8_ASYMM map 17972 .quant8AsymmOperands = {}, 17973 // int -> QUANT16_SYMM map 17974 .quant16SymmOperands = {}, 17975 // int -> FLOAT16 map 17976 .float16Operands = {}, 17977 // int -> BOOL8 map 17978 .bool8Operands = {}, 17979 // int -> QUANT8_SYMM_PER_CHANNEL map 17980 .quant8ChannelOperands = {}, 17981 // int -> QUANT16_ASYMM map 17982 .quant16AsymmOperands = {}, 17983 // int -> QUANT8_SYMM map 17984 .quant8SymmOperands = {}, 17985 }, 17986 //Output(s) 17987 { // See tools/test_generator/include/TestHarness.h:MixedTyped 17988 // int -> Dimensions map 17989 .operandDimensions = {{0, {1, 6, 6, 1}}}, 17990 // int -> FLOAT32 map 17991 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 17992 // int -> INT32 map 17993 .int32Operands = {}, 17994 // int -> QUANT8_ASYMM map 17995 .quant8AsymmOperands = {}, 17996 // int -> QUANT16_SYMM map 17997 .quant16SymmOperands = {}, 17998 // int -> FLOAT16 map 17999 .float16Operands = {}, 18000 // int -> BOOL8 map 18001 .bool8Operands = {}, 18002 // int -> QUANT8_SYMM_PER_CHANNEL map 18003 .quant8ChannelOperands = {}, 18004 // int -> QUANT16_ASYMM map 18005 .quant16AsymmOperands = {}, 18006 // int -> QUANT8_SYMM map 18007 .quant8SymmOperands = {}, 18008 } 18009 }, 18010 }, // End of an example 18011 }; 18012 return examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_3; 18013 }; 18014 18015 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_3() { 18016 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_3 = { 18017 // Begin of an example 18018 { 18019 .operands = { 18020 //Input(s) 18021 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18022 // int -> Dimensions map 18023 .operandDimensions = {{0, {1, 4, 4, 2}}}, 18024 // int -> FLOAT32 map 18025 .float32Operands = {}, 18026 // int -> INT32 map 18027 .int32Operands = {}, 18028 // int -> QUANT8_ASYMM map 18029 .quant8AsymmOperands = {{0, {14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138}}}, 18030 // int -> QUANT16_SYMM map 18031 .quant16SymmOperands = {}, 18032 // int -> FLOAT16 map 18033 .float16Operands = {}, 18034 // int -> BOOL8 map 18035 .bool8Operands = {}, 18036 // int -> QUANT8_SYMM_PER_CHANNEL map 18037 .quant8ChannelOperands = {}, 18038 // int -> QUANT16_ASYMM map 18039 .quant16AsymmOperands = {}, 18040 // int -> QUANT8_SYMM map 18041 .quant8SymmOperands = {}, 18042 }, 18043 //Output(s) 18044 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18045 // int -> Dimensions map 18046 .operandDimensions = {{0, {1, 6, 6, 1}}}, 18047 // int -> FLOAT32 map 18048 .float32Operands = {}, 18049 // int -> INT32 map 18050 .int32Operands = {}, 18051 // int -> QUANT8_ASYMM map 18052 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 18053 // int -> QUANT16_SYMM map 18054 .quant16SymmOperands = {}, 18055 // int -> FLOAT16 map 18056 .float16Operands = {}, 18057 // int -> BOOL8 map 18058 .bool8Operands = {}, 18059 // int -> QUANT8_SYMM_PER_CHANNEL map 18060 .quant8ChannelOperands = {}, 18061 // int -> QUANT16_ASYMM map 18062 .quant16AsymmOperands = {}, 18063 // int -> QUANT8_SYMM map 18064 .quant8SymmOperands = {}, 18065 } 18066 }, 18067 }, // End of an example 18068 }; 18069 return examples_dynamic_output_shape_nhwc_quant8_3; 18070 }; 18071 18072 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_weight_as_input_3() { 18073 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_weight_as_input_3 = { 18074 // Begin of an example 18075 { 18076 .operands = { 18077 //Input(s) 18078 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18079 // int -> Dimensions map 18080 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18081 // int -> FLOAT32 map 18082 .float32Operands = {}, 18083 // int -> INT32 map 18084 .int32Operands = {{2, {0}}}, 18085 // int -> QUANT8_ASYMM map 18086 .quant8AsymmOperands = {{0, {14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 18087 // int -> QUANT16_SYMM map 18088 .quant16SymmOperands = {}, 18089 // int -> FLOAT16 map 18090 .float16Operands = {}, 18091 // int -> BOOL8 map 18092 .bool8Operands = {}, 18093 // int -> QUANT8_SYMM_PER_CHANNEL map 18094 .quant8ChannelOperands = {}, 18095 // int -> QUANT16_ASYMM map 18096 .quant16AsymmOperands = {}, 18097 // int -> QUANT8_SYMM map 18098 .quant8SymmOperands = {}, 18099 }, 18100 //Output(s) 18101 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18102 // int -> Dimensions map 18103 .operandDimensions = {{0, {1, 6, 6, 1}}}, 18104 // int -> FLOAT32 map 18105 .float32Operands = {}, 18106 // int -> INT32 map 18107 .int32Operands = {}, 18108 // int -> QUANT8_ASYMM map 18109 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 18110 // int -> QUANT16_SYMM map 18111 .quant16SymmOperands = {}, 18112 // int -> FLOAT16 map 18113 .float16Operands = {}, 18114 // int -> BOOL8 map 18115 .bool8Operands = {}, 18116 // int -> QUANT8_SYMM_PER_CHANNEL map 18117 .quant8ChannelOperands = {}, 18118 // int -> QUANT16_ASYMM map 18119 .quant16AsymmOperands = {}, 18120 // int -> QUANT8_SYMM map 18121 .quant8SymmOperands = {}, 18122 } 18123 }, 18124 }, // End of an example 18125 }; 18126 return examples_dynamic_output_shape_nhwc_quant8_weight_as_input_3; 18127 }; 18128 18129 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_3() { 18130 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_3 = { 18131 // Begin of an example 18132 { 18133 .operands = { 18134 //Input(s) 18135 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18136 // int -> Dimensions map 18137 .operandDimensions = {{0, {1, 4, 4, 2}}}, 18138 // int -> FLOAT32 map 18139 .float32Operands = {}, 18140 // int -> INT32 map 18141 .int32Operands = {}, 18142 // int -> QUANT8_ASYMM map 18143 .quant8AsymmOperands = {}, 18144 // int -> QUANT16_SYMM map 18145 .quant16SymmOperands = {}, 18146 // int -> FLOAT16 map 18147 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 18148 // int -> BOOL8 map 18149 .bool8Operands = {}, 18150 // int -> QUANT8_SYMM_PER_CHANNEL map 18151 .quant8ChannelOperands = {}, 18152 // int -> QUANT16_ASYMM map 18153 .quant16AsymmOperands = {}, 18154 // int -> QUANT8_SYMM map 18155 .quant8SymmOperands = {}, 18156 }, 18157 //Output(s) 18158 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18159 // int -> Dimensions map 18160 .operandDimensions = {{0, {1, 6, 6, 1}}}, 18161 // int -> FLOAT32 map 18162 .float32Operands = {}, 18163 // int -> INT32 map 18164 .int32Operands = {}, 18165 // int -> QUANT8_ASYMM map 18166 .quant8AsymmOperands = {}, 18167 // int -> QUANT16_SYMM map 18168 .quant16SymmOperands = {}, 18169 // int -> FLOAT16 map 18170 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18171 // int -> BOOL8 map 18172 .bool8Operands = {}, 18173 // int -> QUANT8_SYMM_PER_CHANNEL map 18174 .quant8ChannelOperands = {}, 18175 // int -> QUANT16_ASYMM map 18176 .quant16AsymmOperands = {}, 18177 // int -> QUANT8_SYMM map 18178 .quant8SymmOperands = {}, 18179 } 18180 }, 18181 }, // End of an example 18182 }; 18183 return examples_dynamic_output_shape_nhwc_float16_3; 18184 }; 18185 18186 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_weight_as_input_3() { 18187 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_weight_as_input_3 = { 18188 // Begin of an example 18189 { 18190 .operands = { 18191 //Input(s) 18192 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18193 // int -> Dimensions map 18194 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18195 // int -> FLOAT32 map 18196 .float32Operands = {}, 18197 // int -> INT32 map 18198 .int32Operands = {}, 18199 // int -> QUANT8_ASYMM map 18200 .quant8AsymmOperands = {}, 18201 // int -> QUANT16_SYMM map 18202 .quant16SymmOperands = {}, 18203 // int -> FLOAT16 map 18204 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18205 // int -> BOOL8 map 18206 .bool8Operands = {}, 18207 // int -> QUANT8_SYMM_PER_CHANNEL map 18208 .quant8ChannelOperands = {}, 18209 // int -> QUANT16_ASYMM map 18210 .quant16AsymmOperands = {}, 18211 // int -> QUANT8_SYMM map 18212 .quant8SymmOperands = {}, 18213 }, 18214 //Output(s) 18215 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18216 // int -> Dimensions map 18217 .operandDimensions = {{0, {1, 6, 6, 1}}}, 18218 // int -> FLOAT32 map 18219 .float32Operands = {}, 18220 // int -> INT32 map 18221 .int32Operands = {}, 18222 // int -> QUANT8_ASYMM map 18223 .quant8AsymmOperands = {}, 18224 // int -> QUANT16_SYMM map 18225 .quant16SymmOperands = {}, 18226 // int -> FLOAT16 map 18227 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18228 // int -> BOOL8 map 18229 .bool8Operands = {}, 18230 // int -> QUANT8_SYMM_PER_CHANNEL map 18231 .quant8ChannelOperands = {}, 18232 // int -> QUANT16_ASYMM map 18233 .quant16AsymmOperands = {}, 18234 // int -> QUANT8_SYMM map 18235 .quant8SymmOperands = {}, 18236 } 18237 }, 18238 }, // End of an example 18239 }; 18240 return examples_dynamic_output_shape_nhwc_float16_weight_as_input_3; 18241 }; 18242 18243 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_3() { 18244 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_3 = { 18245 // Begin of an example 18246 { 18247 .operands = { 18248 //Input(s) 18249 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18250 // int -> Dimensions map 18251 .operandDimensions = {{0, {1, 2, 4, 4}}}, 18252 // int -> FLOAT32 map 18253 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 18254 // int -> INT32 map 18255 .int32Operands = {}, 18256 // int -> QUANT8_ASYMM map 18257 .quant8AsymmOperands = {}, 18258 // int -> QUANT16_SYMM map 18259 .quant16SymmOperands = {}, 18260 // int -> FLOAT16 map 18261 .float16Operands = {}, 18262 // int -> BOOL8 map 18263 .bool8Operands = {}, 18264 // int -> QUANT8_SYMM_PER_CHANNEL map 18265 .quant8ChannelOperands = {}, 18266 // int -> QUANT16_ASYMM map 18267 .quant16AsymmOperands = {}, 18268 // int -> QUANT8_SYMM map 18269 .quant8SymmOperands = {}, 18270 }, 18271 //Output(s) 18272 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18273 // int -> Dimensions map 18274 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18275 // int -> FLOAT32 map 18276 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18277 // int -> INT32 map 18278 .int32Operands = {}, 18279 // int -> QUANT8_ASYMM map 18280 .quant8AsymmOperands = {}, 18281 // int -> QUANT16_SYMM map 18282 .quant16SymmOperands = {}, 18283 // int -> FLOAT16 map 18284 .float16Operands = {}, 18285 // int -> BOOL8 map 18286 .bool8Operands = {}, 18287 // int -> QUANT8_SYMM_PER_CHANNEL map 18288 .quant8ChannelOperands = {}, 18289 // int -> QUANT16_ASYMM map 18290 .quant16AsymmOperands = {}, 18291 // int -> QUANT8_SYMM map 18292 .quant8SymmOperands = {}, 18293 } 18294 }, 18295 }, // End of an example 18296 }; 18297 return examples_dynamic_output_shape_nchw_3; 18298 }; 18299 18300 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_3() { 18301 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_3 = { 18302 // Begin of an example 18303 { 18304 .operands = { 18305 //Input(s) 18306 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18307 // int -> Dimensions map 18308 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18309 // int -> FLOAT32 map 18310 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18311 // int -> INT32 map 18312 .int32Operands = {}, 18313 // int -> QUANT8_ASYMM map 18314 .quant8AsymmOperands = {}, 18315 // int -> QUANT16_SYMM map 18316 .quant16SymmOperands = {}, 18317 // int -> FLOAT16 map 18318 .float16Operands = {}, 18319 // int -> BOOL8 map 18320 .bool8Operands = {}, 18321 // int -> QUANT8_SYMM_PER_CHANNEL map 18322 .quant8ChannelOperands = {}, 18323 // int -> QUANT16_ASYMM map 18324 .quant16AsymmOperands = {}, 18325 // int -> QUANT8_SYMM map 18326 .quant8SymmOperands = {}, 18327 }, 18328 //Output(s) 18329 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18330 // int -> Dimensions map 18331 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18332 // int -> FLOAT32 map 18333 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18334 // int -> INT32 map 18335 .int32Operands = {}, 18336 // int -> QUANT8_ASYMM map 18337 .quant8AsymmOperands = {}, 18338 // int -> QUANT16_SYMM map 18339 .quant16SymmOperands = {}, 18340 // int -> FLOAT16 map 18341 .float16Operands = {}, 18342 // int -> BOOL8 map 18343 .bool8Operands = {}, 18344 // int -> QUANT8_SYMM_PER_CHANNEL map 18345 .quant8ChannelOperands = {}, 18346 // int -> QUANT16_ASYMM map 18347 .quant16AsymmOperands = {}, 18348 // int -> QUANT8_SYMM map 18349 .quant8SymmOperands = {}, 18350 } 18351 }, 18352 }, // End of an example 18353 }; 18354 return examples_dynamic_output_shape_nchw_weight_as_input_3; 18355 }; 18356 18357 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_3() { 18358 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_3 = { 18359 // Begin of an example 18360 { 18361 .operands = { 18362 //Input(s) 18363 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18364 // int -> Dimensions map 18365 .operandDimensions = {{0, {1, 2, 4, 4}}}, 18366 // int -> FLOAT32 map 18367 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 18368 // int -> INT32 map 18369 .int32Operands = {}, 18370 // int -> QUANT8_ASYMM map 18371 .quant8AsymmOperands = {}, 18372 // int -> QUANT16_SYMM map 18373 .quant16SymmOperands = {}, 18374 // int -> FLOAT16 map 18375 .float16Operands = {}, 18376 // int -> BOOL8 map 18377 .bool8Operands = {}, 18378 // int -> QUANT8_SYMM_PER_CHANNEL map 18379 .quant8ChannelOperands = {}, 18380 // int -> QUANT16_ASYMM map 18381 .quant16AsymmOperands = {}, 18382 // int -> QUANT8_SYMM map 18383 .quant8SymmOperands = {}, 18384 }, 18385 //Output(s) 18386 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18387 // int -> Dimensions map 18388 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18389 // int -> FLOAT32 map 18390 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18391 // int -> INT32 map 18392 .int32Operands = {}, 18393 // int -> QUANT8_ASYMM map 18394 .quant8AsymmOperands = {}, 18395 // int -> QUANT16_SYMM map 18396 .quant16SymmOperands = {}, 18397 // int -> FLOAT16 map 18398 .float16Operands = {}, 18399 // int -> BOOL8 map 18400 .bool8Operands = {}, 18401 // int -> QUANT8_SYMM_PER_CHANNEL map 18402 .quant8ChannelOperands = {}, 18403 // int -> QUANT16_ASYMM map 18404 .quant16AsymmOperands = {}, 18405 // int -> QUANT8_SYMM map 18406 .quant8SymmOperands = {}, 18407 } 18408 }, 18409 }, // End of an example 18410 }; 18411 return examples_dynamic_output_shape_nchw_relaxed_3; 18412 }; 18413 18414 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_weight_as_input_3() { 18415 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_weight_as_input_3 = { 18416 // Begin of an example 18417 { 18418 .operands = { 18419 //Input(s) 18420 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18421 // int -> Dimensions map 18422 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18423 // int -> FLOAT32 map 18424 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18425 // int -> INT32 map 18426 .int32Operands = {}, 18427 // int -> QUANT8_ASYMM map 18428 .quant8AsymmOperands = {}, 18429 // int -> QUANT16_SYMM map 18430 .quant16SymmOperands = {}, 18431 // int -> FLOAT16 map 18432 .float16Operands = {}, 18433 // int -> BOOL8 map 18434 .bool8Operands = {}, 18435 // int -> QUANT8_SYMM_PER_CHANNEL map 18436 .quant8ChannelOperands = {}, 18437 // int -> QUANT16_ASYMM map 18438 .quant16AsymmOperands = {}, 18439 // int -> QUANT8_SYMM map 18440 .quant8SymmOperands = {}, 18441 }, 18442 //Output(s) 18443 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18444 // int -> Dimensions map 18445 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18446 // int -> FLOAT32 map 18447 .float32Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18448 // int -> INT32 map 18449 .int32Operands = {}, 18450 // int -> QUANT8_ASYMM map 18451 .quant8AsymmOperands = {}, 18452 // int -> QUANT16_SYMM map 18453 .quant16SymmOperands = {}, 18454 // int -> FLOAT16 map 18455 .float16Operands = {}, 18456 // int -> BOOL8 map 18457 .bool8Operands = {}, 18458 // int -> QUANT8_SYMM_PER_CHANNEL map 18459 .quant8ChannelOperands = {}, 18460 // int -> QUANT16_ASYMM map 18461 .quant16AsymmOperands = {}, 18462 // int -> QUANT8_SYMM map 18463 .quant8SymmOperands = {}, 18464 } 18465 }, 18466 }, // End of an example 18467 }; 18468 return examples_dynamic_output_shape_nchw_relaxed_weight_as_input_3; 18469 }; 18470 18471 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_3() { 18472 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_3 = { 18473 // Begin of an example 18474 { 18475 .operands = { 18476 //Input(s) 18477 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18478 // int -> Dimensions map 18479 .operandDimensions = {{0, {1, 2, 4, 4}}}, 18480 // int -> FLOAT32 map 18481 .float32Operands = {}, 18482 // int -> INT32 map 18483 .int32Operands = {}, 18484 // int -> QUANT8_ASYMM map 18485 .quant8AsymmOperands = {{0, {14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, 130, 138}}}, 18486 // int -> QUANT16_SYMM map 18487 .quant16SymmOperands = {}, 18488 // int -> FLOAT16 map 18489 .float16Operands = {}, 18490 // int -> BOOL8 map 18491 .bool8Operands = {}, 18492 // int -> QUANT8_SYMM_PER_CHANNEL map 18493 .quant8ChannelOperands = {}, 18494 // int -> QUANT16_ASYMM map 18495 .quant16AsymmOperands = {}, 18496 // int -> QUANT8_SYMM map 18497 .quant8SymmOperands = {}, 18498 }, 18499 //Output(s) 18500 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18501 // int -> Dimensions map 18502 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18503 // int -> FLOAT32 map 18504 .float32Operands = {}, 18505 // int -> INT32 map 18506 .int32Operands = {}, 18507 // int -> QUANT8_ASYMM map 18508 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 18509 // int -> QUANT16_SYMM map 18510 .quant16SymmOperands = {}, 18511 // int -> FLOAT16 map 18512 .float16Operands = {}, 18513 // int -> BOOL8 map 18514 .bool8Operands = {}, 18515 // int -> QUANT8_SYMM_PER_CHANNEL map 18516 .quant8ChannelOperands = {}, 18517 // int -> QUANT16_ASYMM map 18518 .quant16AsymmOperands = {}, 18519 // int -> QUANT8_SYMM map 18520 .quant8SymmOperands = {}, 18521 } 18522 }, 18523 }, // End of an example 18524 }; 18525 return examples_dynamic_output_shape_nchw_quant8_3; 18526 }; 18527 18528 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_weight_as_input_3() { 18529 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_weight_as_input_3 = { 18530 // Begin of an example 18531 { 18532 .operands = { 18533 //Input(s) 18534 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18535 // int -> Dimensions map 18536 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18537 // int -> FLOAT32 map 18538 .float32Operands = {}, 18539 // int -> INT32 map 18540 .int32Operands = {{2, {0}}}, 18541 // int -> QUANT8_ASYMM map 18542 .quant8AsymmOperands = {{0, {14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, 130, 138}}, {1, {130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 18543 // int -> QUANT16_SYMM map 18544 .quant16SymmOperands = {}, 18545 // int -> FLOAT16 map 18546 .float16Operands = {}, 18547 // int -> BOOL8 map 18548 .bool8Operands = {}, 18549 // int -> QUANT8_SYMM_PER_CHANNEL map 18550 .quant8ChannelOperands = {}, 18551 // int -> QUANT16_ASYMM map 18552 .quant16AsymmOperands = {}, 18553 // int -> QUANT8_SYMM map 18554 .quant8SymmOperands = {}, 18555 }, 18556 //Output(s) 18557 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18558 // int -> Dimensions map 18559 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18560 // int -> FLOAT32 map 18561 .float32Operands = {}, 18562 // int -> INT32 map 18563 .int32Operands = {}, 18564 // int -> QUANT8_ASYMM map 18565 .quant8AsymmOperands = {{0, {80, 81, 82, 83, 84, 83, 82, 86, 93, 98, 96, 91, 87, 101, 122, 133, 125, 107, 99, 127, 165, 176, 156, 125, 107, 142, 185, 194, 166, 128, 102, 128, 159, 165, 143, 114}}}, 18566 // int -> QUANT16_SYMM map 18567 .quant16SymmOperands = {}, 18568 // int -> FLOAT16 map 18569 .float16Operands = {}, 18570 // int -> BOOL8 map 18571 .bool8Operands = {}, 18572 // int -> QUANT8_SYMM_PER_CHANNEL map 18573 .quant8ChannelOperands = {}, 18574 // int -> QUANT16_ASYMM map 18575 .quant16AsymmOperands = {}, 18576 // int -> QUANT8_SYMM map 18577 .quant8SymmOperands = {}, 18578 } 18579 }, 18580 }, // End of an example 18581 }; 18582 return examples_dynamic_output_shape_nchw_quant8_weight_as_input_3; 18583 }; 18584 18585 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_3() { 18586 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_3 = { 18587 // Begin of an example 18588 { 18589 .operands = { 18590 //Input(s) 18591 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18592 // int -> Dimensions map 18593 .operandDimensions = {{0, {1, 2, 4, 4}}}, 18594 // int -> FLOAT32 map 18595 .float32Operands = {}, 18596 // int -> INT32 map 18597 .int32Operands = {}, 18598 // int -> QUANT8_ASYMM map 18599 .quant8AsymmOperands = {}, 18600 // int -> QUANT16_SYMM map 18601 .quant16SymmOperands = {}, 18602 // int -> FLOAT16 map 18603 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 18604 // int -> BOOL8 map 18605 .bool8Operands = {}, 18606 // int -> QUANT8_SYMM_PER_CHANNEL map 18607 .quant8ChannelOperands = {}, 18608 // int -> QUANT16_ASYMM map 18609 .quant16AsymmOperands = {}, 18610 // int -> QUANT8_SYMM map 18611 .quant8SymmOperands = {}, 18612 }, 18613 //Output(s) 18614 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18615 // int -> Dimensions map 18616 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18617 // int -> FLOAT32 map 18618 .float32Operands = {}, 18619 // int -> INT32 map 18620 .int32Operands = {}, 18621 // int -> QUANT8_ASYMM map 18622 .quant8AsymmOperands = {}, 18623 // int -> QUANT16_SYMM map 18624 .quant16SymmOperands = {}, 18625 // int -> FLOAT16 map 18626 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18627 // int -> BOOL8 map 18628 .bool8Operands = {}, 18629 // int -> QUANT8_SYMM_PER_CHANNEL map 18630 .quant8ChannelOperands = {}, 18631 // int -> QUANT16_ASYMM map 18632 .quant16AsymmOperands = {}, 18633 // int -> QUANT8_SYMM map 18634 .quant8SymmOperands = {}, 18635 } 18636 }, 18637 }, // End of an example 18638 }; 18639 return examples_dynamic_output_shape_nchw_float16_3; 18640 }; 18641 18642 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_weight_as_input_3() { 18643 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_weight_as_input_3 = { 18644 // Begin of an example 18645 { 18646 .operands = { 18647 //Input(s) 18648 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18649 // int -> Dimensions map 18650 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18651 // int -> FLOAT32 map 18652 .float32Operands = {}, 18653 // int -> INT32 map 18654 .int32Operands = {}, 18655 // int -> QUANT8_ASYMM map 18656 .quant8AsymmOperands = {}, 18657 // int -> QUANT16_SYMM map 18658 .quant16SymmOperands = {}, 18659 // int -> FLOAT16 map 18660 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18661 // int -> BOOL8 map 18662 .bool8Operands = {}, 18663 // int -> QUANT8_SYMM_PER_CHANNEL map 18664 .quant8ChannelOperands = {}, 18665 // int -> QUANT16_ASYMM map 18666 .quant16AsymmOperands = {}, 18667 // int -> QUANT8_SYMM map 18668 .quant8SymmOperands = {}, 18669 }, 18670 //Output(s) 18671 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18672 // int -> Dimensions map 18673 .operandDimensions = {{0, {1, 1, 6, 6}}}, 18674 // int -> FLOAT32 map 18675 .float32Operands = {}, 18676 // int -> INT32 map 18677 .int32Operands = {}, 18678 // int -> QUANT8_ASYMM map 18679 .quant8AsymmOperands = {}, 18680 // int -> QUANT16_SYMM map 18681 .quant16SymmOperands = {}, 18682 // int -> FLOAT16 map 18683 .float16Operands = {{0, {5.0f, 22.0f, 59.0f, 101.0f, 114.0f, 83.0f, 52.0f, 184.0f, 412.0f, 568.0f, 528.0f, 344.0f, 237.0f, 678.0f, 1347.0f, 1689.0f, 1434.0f, 879.0f, 597.0f, 1494.0f, 2715.0f, 3057.0f, 2442.0f, 1431.0f, 856.0f, 1968.0f, 3352.0f, 3652.0f, 2760.0f, 1548.0f, 689.0f, 1534.0f, 2543.0f, 2729.0f, 2010.0f, 1103.0f}}}, 18684 // int -> BOOL8 map 18685 .bool8Operands = {}, 18686 // int -> QUANT8_SYMM_PER_CHANNEL map 18687 .quant8ChannelOperands = {}, 18688 // int -> QUANT16_ASYMM map 18689 .quant16AsymmOperands = {}, 18690 // int -> QUANT8_SYMM map 18691 .quant8SymmOperands = {}, 18692 } 18693 }, 18694 }, // End of an example 18695 }; 18696 return examples_dynamic_output_shape_nchw_float16_weight_as_input_3; 18697 }; 18698 18699 std::vector<MixedTypedExample>& get_examples_nhwc_4() { 18700 static std::vector<MixedTypedExample> examples_nhwc_4 = { 18701 // Begin of an example 18702 { 18703 .operands = { 18704 //Input(s) 18705 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18706 // int -> Dimensions map 18707 .operandDimensions = {{0, {1, 4, 4, 2}}}, 18708 // int -> FLOAT32 map 18709 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 18710 // int -> INT32 map 18711 .int32Operands = {}, 18712 // int -> QUANT8_ASYMM map 18713 .quant8AsymmOperands = {}, 18714 // int -> QUANT16_SYMM map 18715 .quant16SymmOperands = {}, 18716 // int -> FLOAT16 map 18717 .float16Operands = {}, 18718 // int -> BOOL8 map 18719 .bool8Operands = {}, 18720 // int -> QUANT8_SYMM_PER_CHANNEL map 18721 .quant8ChannelOperands = {}, 18722 // int -> QUANT16_ASYMM map 18723 .quant16AsymmOperands = {}, 18724 // int -> QUANT8_SYMM map 18725 .quant8SymmOperands = {}, 18726 }, 18727 //Output(s) 18728 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18729 // int -> Dimensions map 18730 .operandDimensions = {{0, {1, 3, 3, 1}}}, 18731 // int -> FLOAT32 map 18732 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 18733 // int -> INT32 map 18734 .int32Operands = {}, 18735 // int -> QUANT8_ASYMM map 18736 .quant8AsymmOperands = {}, 18737 // int -> QUANT16_SYMM map 18738 .quant16SymmOperands = {}, 18739 // int -> FLOAT16 map 18740 .float16Operands = {}, 18741 // int -> BOOL8 map 18742 .bool8Operands = {}, 18743 // int -> QUANT8_SYMM_PER_CHANNEL map 18744 .quant8ChannelOperands = {}, 18745 // int -> QUANT16_ASYMM map 18746 .quant16AsymmOperands = {}, 18747 // int -> QUANT8_SYMM map 18748 .quant8SymmOperands = {}, 18749 } 18750 }, 18751 }, // End of an example 18752 }; 18753 return examples_nhwc_4; 18754 }; 18755 18756 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_4() { 18757 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_4 = { 18758 // Begin of an example 18759 { 18760 .operands = { 18761 //Input(s) 18762 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18763 // int -> Dimensions map 18764 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18765 // int -> FLOAT32 map 18766 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18767 // int -> INT32 map 18768 .int32Operands = {}, 18769 // int -> QUANT8_ASYMM map 18770 .quant8AsymmOperands = {}, 18771 // int -> QUANT16_SYMM map 18772 .quant16SymmOperands = {}, 18773 // int -> FLOAT16 map 18774 .float16Operands = {}, 18775 // int -> BOOL8 map 18776 .bool8Operands = {}, 18777 // int -> QUANT8_SYMM_PER_CHANNEL map 18778 .quant8ChannelOperands = {}, 18779 // int -> QUANT16_ASYMM map 18780 .quant16AsymmOperands = {}, 18781 // int -> QUANT8_SYMM map 18782 .quant8SymmOperands = {}, 18783 }, 18784 //Output(s) 18785 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18786 // int -> Dimensions map 18787 .operandDimensions = {{0, {1, 3, 3, 1}}}, 18788 // int -> FLOAT32 map 18789 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 18790 // int -> INT32 map 18791 .int32Operands = {}, 18792 // int -> QUANT8_ASYMM map 18793 .quant8AsymmOperands = {}, 18794 // int -> QUANT16_SYMM map 18795 .quant16SymmOperands = {}, 18796 // int -> FLOAT16 map 18797 .float16Operands = {}, 18798 // int -> BOOL8 map 18799 .bool8Operands = {}, 18800 // int -> QUANT8_SYMM_PER_CHANNEL map 18801 .quant8ChannelOperands = {}, 18802 // int -> QUANT16_ASYMM map 18803 .quant16AsymmOperands = {}, 18804 // int -> QUANT8_SYMM map 18805 .quant8SymmOperands = {}, 18806 } 18807 }, 18808 }, // End of an example 18809 }; 18810 return examples_nhwc_weight_as_input_4; 18811 }; 18812 18813 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_4() { 18814 static std::vector<MixedTypedExample> examples_nhwc_relaxed_4 = { 18815 // Begin of an example 18816 { 18817 .operands = { 18818 //Input(s) 18819 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18820 // int -> Dimensions map 18821 .operandDimensions = {{0, {1, 4, 4, 2}}}, 18822 // int -> FLOAT32 map 18823 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 18824 // int -> INT32 map 18825 .int32Operands = {}, 18826 // int -> QUANT8_ASYMM map 18827 .quant8AsymmOperands = {}, 18828 // int -> QUANT16_SYMM map 18829 .quant16SymmOperands = {}, 18830 // int -> FLOAT16 map 18831 .float16Operands = {}, 18832 // int -> BOOL8 map 18833 .bool8Operands = {}, 18834 // int -> QUANT8_SYMM_PER_CHANNEL map 18835 .quant8ChannelOperands = {}, 18836 // int -> QUANT16_ASYMM map 18837 .quant16AsymmOperands = {}, 18838 // int -> QUANT8_SYMM map 18839 .quant8SymmOperands = {}, 18840 }, 18841 //Output(s) 18842 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18843 // int -> Dimensions map 18844 .operandDimensions = {{0, {1, 3, 3, 1}}}, 18845 // int -> FLOAT32 map 18846 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 18847 // int -> INT32 map 18848 .int32Operands = {}, 18849 // int -> QUANT8_ASYMM map 18850 .quant8AsymmOperands = {}, 18851 // int -> QUANT16_SYMM map 18852 .quant16SymmOperands = {}, 18853 // int -> FLOAT16 map 18854 .float16Operands = {}, 18855 // int -> BOOL8 map 18856 .bool8Operands = {}, 18857 // int -> QUANT8_SYMM_PER_CHANNEL map 18858 .quant8ChannelOperands = {}, 18859 // int -> QUANT16_ASYMM map 18860 .quant16AsymmOperands = {}, 18861 // int -> QUANT8_SYMM map 18862 .quant8SymmOperands = {}, 18863 } 18864 }, 18865 }, // End of an example 18866 }; 18867 return examples_nhwc_relaxed_4; 18868 }; 18869 18870 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_weight_as_input_4() { 18871 static std::vector<MixedTypedExample> examples_nhwc_relaxed_weight_as_input_4 = { 18872 // Begin of an example 18873 { 18874 .operands = { 18875 //Input(s) 18876 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18877 // int -> Dimensions map 18878 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18879 // int -> FLOAT32 map 18880 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 18881 // int -> INT32 map 18882 .int32Operands = {}, 18883 // int -> QUANT8_ASYMM map 18884 .quant8AsymmOperands = {}, 18885 // int -> QUANT16_SYMM map 18886 .quant16SymmOperands = {}, 18887 // int -> FLOAT16 map 18888 .float16Operands = {}, 18889 // int -> BOOL8 map 18890 .bool8Operands = {}, 18891 // int -> QUANT8_SYMM_PER_CHANNEL map 18892 .quant8ChannelOperands = {}, 18893 // int -> QUANT16_ASYMM map 18894 .quant16AsymmOperands = {}, 18895 // int -> QUANT8_SYMM map 18896 .quant8SymmOperands = {}, 18897 }, 18898 //Output(s) 18899 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18900 // int -> Dimensions map 18901 .operandDimensions = {{0, {1, 3, 3, 1}}}, 18902 // int -> FLOAT32 map 18903 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 18904 // int -> INT32 map 18905 .int32Operands = {}, 18906 // int -> QUANT8_ASYMM map 18907 .quant8AsymmOperands = {}, 18908 // int -> QUANT16_SYMM map 18909 .quant16SymmOperands = {}, 18910 // int -> FLOAT16 map 18911 .float16Operands = {}, 18912 // int -> BOOL8 map 18913 .bool8Operands = {}, 18914 // int -> QUANT8_SYMM_PER_CHANNEL map 18915 .quant8ChannelOperands = {}, 18916 // int -> QUANT16_ASYMM map 18917 .quant16AsymmOperands = {}, 18918 // int -> QUANT8_SYMM map 18919 .quant8SymmOperands = {}, 18920 } 18921 }, 18922 }, // End of an example 18923 }; 18924 return examples_nhwc_relaxed_weight_as_input_4; 18925 }; 18926 18927 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_4() { 18928 static std::vector<MixedTypedExample> examples_nhwc_quant8_4 = { 18929 // Begin of an example 18930 { 18931 .operands = { 18932 //Input(s) 18933 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18934 // int -> Dimensions map 18935 .operandDimensions = {{0, {1, 4, 4, 2}}}, 18936 // int -> FLOAT32 map 18937 .float32Operands = {}, 18938 // int -> INT32 map 18939 .int32Operands = {}, 18940 // int -> QUANT8_ASYMM map 18941 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 18942 // int -> QUANT16_SYMM map 18943 .quant16SymmOperands = {}, 18944 // int -> FLOAT16 map 18945 .float16Operands = {}, 18946 // int -> BOOL8 map 18947 .bool8Operands = {}, 18948 // int -> QUANT8_SYMM_PER_CHANNEL map 18949 .quant8ChannelOperands = {}, 18950 // int -> QUANT16_ASYMM map 18951 .quant16AsymmOperands = {}, 18952 // int -> QUANT8_SYMM map 18953 .quant8SymmOperands = {}, 18954 }, 18955 //Output(s) 18956 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18957 // int -> Dimensions map 18958 .operandDimensions = {{0, {1, 3, 3, 1}}}, 18959 // int -> FLOAT32 map 18960 .float32Operands = {}, 18961 // int -> INT32 map 18962 .int32Operands = {}, 18963 // int -> QUANT8_ASYMM map 18964 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 18965 // int -> QUANT16_SYMM map 18966 .quant16SymmOperands = {}, 18967 // int -> FLOAT16 map 18968 .float16Operands = {}, 18969 // int -> BOOL8 map 18970 .bool8Operands = {}, 18971 // int -> QUANT8_SYMM_PER_CHANNEL map 18972 .quant8ChannelOperands = {}, 18973 // int -> QUANT16_ASYMM map 18974 .quant16AsymmOperands = {}, 18975 // int -> QUANT8_SYMM map 18976 .quant8SymmOperands = {}, 18977 } 18978 }, 18979 }, // End of an example 18980 }; 18981 return examples_nhwc_quant8_4; 18982 }; 18983 18984 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_weight_as_input_4() { 18985 static std::vector<MixedTypedExample> examples_nhwc_quant8_weight_as_input_4 = { 18986 // Begin of an example 18987 { 18988 .operands = { 18989 //Input(s) 18990 { // See tools/test_generator/include/TestHarness.h:MixedTyped 18991 // int -> Dimensions map 18992 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 18993 // int -> FLOAT32 map 18994 .float32Operands = {}, 18995 // int -> INT32 map 18996 .int32Operands = {{2, {0}}}, 18997 // int -> QUANT8_ASYMM map 18998 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}, {1, {132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200}}}, 18999 // int -> QUANT16_SYMM map 19000 .quant16SymmOperands = {}, 19001 // int -> FLOAT16 map 19002 .float16Operands = {}, 19003 // int -> BOOL8 map 19004 .bool8Operands = {}, 19005 // int -> QUANT8_SYMM_PER_CHANNEL map 19006 .quant8ChannelOperands = {}, 19007 // int -> QUANT16_ASYMM map 19008 .quant16AsymmOperands = {}, 19009 // int -> QUANT8_SYMM map 19010 .quant8SymmOperands = {}, 19011 }, 19012 //Output(s) 19013 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19014 // int -> Dimensions map 19015 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19016 // int -> FLOAT32 map 19017 .float32Operands = {}, 19018 // int -> INT32 map 19019 .int32Operands = {}, 19020 // int -> QUANT8_ASYMM map 19021 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 19022 // int -> QUANT16_SYMM map 19023 .quant16SymmOperands = {}, 19024 // int -> FLOAT16 map 19025 .float16Operands = {}, 19026 // int -> BOOL8 map 19027 .bool8Operands = {}, 19028 // int -> QUANT8_SYMM_PER_CHANNEL map 19029 .quant8ChannelOperands = {}, 19030 // int -> QUANT16_ASYMM map 19031 .quant16AsymmOperands = {}, 19032 // int -> QUANT8_SYMM map 19033 .quant8SymmOperands = {}, 19034 } 19035 }, 19036 }, // End of an example 19037 }; 19038 return examples_nhwc_quant8_weight_as_input_4; 19039 }; 19040 19041 std::vector<MixedTypedExample>& get_examples_nhwc_float16_4() { 19042 static std::vector<MixedTypedExample> examples_nhwc_float16_4 = { 19043 // Begin of an example 19044 { 19045 .operands = { 19046 //Input(s) 19047 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19048 // int -> Dimensions map 19049 .operandDimensions = {{0, {1, 4, 4, 2}}}, 19050 // int -> FLOAT32 map 19051 .float32Operands = {}, 19052 // int -> INT32 map 19053 .int32Operands = {}, 19054 // int -> QUANT8_ASYMM map 19055 .quant8AsymmOperands = {}, 19056 // int -> QUANT16_SYMM map 19057 .quant16SymmOperands = {}, 19058 // int -> FLOAT16 map 19059 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 19060 // int -> BOOL8 map 19061 .bool8Operands = {}, 19062 // int -> QUANT8_SYMM_PER_CHANNEL map 19063 .quant8ChannelOperands = {}, 19064 // int -> QUANT16_ASYMM map 19065 .quant16AsymmOperands = {}, 19066 // int -> QUANT8_SYMM map 19067 .quant8SymmOperands = {}, 19068 }, 19069 //Output(s) 19070 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19071 // int -> Dimensions map 19072 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19073 // int -> FLOAT32 map 19074 .float32Operands = {}, 19075 // int -> INT32 map 19076 .int32Operands = {}, 19077 // int -> QUANT8_ASYMM map 19078 .quant8AsymmOperands = {}, 19079 // int -> QUANT16_SYMM map 19080 .quant16SymmOperands = {}, 19081 // int -> FLOAT16 map 19082 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19083 // int -> BOOL8 map 19084 .bool8Operands = {}, 19085 // int -> QUANT8_SYMM_PER_CHANNEL map 19086 .quant8ChannelOperands = {}, 19087 // int -> QUANT16_ASYMM map 19088 .quant16AsymmOperands = {}, 19089 // int -> QUANT8_SYMM map 19090 .quant8SymmOperands = {}, 19091 } 19092 }, 19093 }, // End of an example 19094 }; 19095 return examples_nhwc_float16_4; 19096 }; 19097 19098 std::vector<MixedTypedExample>& get_examples_nhwc_float16_weight_as_input_4() { 19099 static std::vector<MixedTypedExample> examples_nhwc_float16_weight_as_input_4 = { 19100 // Begin of an example 19101 { 19102 .operands = { 19103 //Input(s) 19104 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19105 // int -> Dimensions map 19106 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19107 // int -> FLOAT32 map 19108 .float32Operands = {}, 19109 // int -> INT32 map 19110 .int32Operands = {}, 19111 // int -> QUANT8_ASYMM map 19112 .quant8AsymmOperands = {}, 19113 // int -> QUANT16_SYMM map 19114 .quant16SymmOperands = {}, 19115 // int -> FLOAT16 map 19116 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19117 // int -> BOOL8 map 19118 .bool8Operands = {}, 19119 // int -> QUANT8_SYMM_PER_CHANNEL map 19120 .quant8ChannelOperands = {}, 19121 // int -> QUANT16_ASYMM map 19122 .quant16AsymmOperands = {}, 19123 // int -> QUANT8_SYMM map 19124 .quant8SymmOperands = {}, 19125 }, 19126 //Output(s) 19127 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19128 // int -> Dimensions map 19129 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19130 // int -> FLOAT32 map 19131 .float32Operands = {}, 19132 // int -> INT32 map 19133 .int32Operands = {}, 19134 // int -> QUANT8_ASYMM map 19135 .quant8AsymmOperands = {}, 19136 // int -> QUANT16_SYMM map 19137 .quant16SymmOperands = {}, 19138 // int -> FLOAT16 map 19139 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19140 // int -> BOOL8 map 19141 .bool8Operands = {}, 19142 // int -> QUANT8_SYMM_PER_CHANNEL map 19143 .quant8ChannelOperands = {}, 19144 // int -> QUANT16_ASYMM map 19145 .quant16AsymmOperands = {}, 19146 // int -> QUANT8_SYMM map 19147 .quant8SymmOperands = {}, 19148 } 19149 }, 19150 }, // End of an example 19151 }; 19152 return examples_nhwc_float16_weight_as_input_4; 19153 }; 19154 19155 std::vector<MixedTypedExample>& get_examples_nchw_4() { 19156 static std::vector<MixedTypedExample> examples_nchw_4 = { 19157 // Begin of an example 19158 { 19159 .operands = { 19160 //Input(s) 19161 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19162 // int -> Dimensions map 19163 .operandDimensions = {{0, {1, 2, 4, 4}}}, 19164 // int -> FLOAT32 map 19165 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 19166 // int -> INT32 map 19167 .int32Operands = {}, 19168 // int -> QUANT8_ASYMM map 19169 .quant8AsymmOperands = {}, 19170 // int -> QUANT16_SYMM map 19171 .quant16SymmOperands = {}, 19172 // int -> FLOAT16 map 19173 .float16Operands = {}, 19174 // int -> BOOL8 map 19175 .bool8Operands = {}, 19176 // int -> QUANT8_SYMM_PER_CHANNEL map 19177 .quant8ChannelOperands = {}, 19178 // int -> QUANT16_ASYMM map 19179 .quant16AsymmOperands = {}, 19180 // int -> QUANT8_SYMM map 19181 .quant8SymmOperands = {}, 19182 }, 19183 //Output(s) 19184 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19185 // int -> Dimensions map 19186 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19187 // int -> FLOAT32 map 19188 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19189 // int -> INT32 map 19190 .int32Operands = {}, 19191 // int -> QUANT8_ASYMM map 19192 .quant8AsymmOperands = {}, 19193 // int -> QUANT16_SYMM map 19194 .quant16SymmOperands = {}, 19195 // int -> FLOAT16 map 19196 .float16Operands = {}, 19197 // int -> BOOL8 map 19198 .bool8Operands = {}, 19199 // int -> QUANT8_SYMM_PER_CHANNEL map 19200 .quant8ChannelOperands = {}, 19201 // int -> QUANT16_ASYMM map 19202 .quant16AsymmOperands = {}, 19203 // int -> QUANT8_SYMM map 19204 .quant8SymmOperands = {}, 19205 } 19206 }, 19207 }, // End of an example 19208 }; 19209 return examples_nchw_4; 19210 }; 19211 19212 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_4() { 19213 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_4 = { 19214 // Begin of an example 19215 { 19216 .operands = { 19217 //Input(s) 19218 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19219 // int -> Dimensions map 19220 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19221 // int -> FLOAT32 map 19222 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19223 // int -> INT32 map 19224 .int32Operands = {}, 19225 // int -> QUANT8_ASYMM map 19226 .quant8AsymmOperands = {}, 19227 // int -> QUANT16_SYMM map 19228 .quant16SymmOperands = {}, 19229 // int -> FLOAT16 map 19230 .float16Operands = {}, 19231 // int -> BOOL8 map 19232 .bool8Operands = {}, 19233 // int -> QUANT8_SYMM_PER_CHANNEL map 19234 .quant8ChannelOperands = {}, 19235 // int -> QUANT16_ASYMM map 19236 .quant16AsymmOperands = {}, 19237 // int -> QUANT8_SYMM map 19238 .quant8SymmOperands = {}, 19239 }, 19240 //Output(s) 19241 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19242 // int -> Dimensions map 19243 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19244 // int -> FLOAT32 map 19245 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19246 // int -> INT32 map 19247 .int32Operands = {}, 19248 // int -> QUANT8_ASYMM map 19249 .quant8AsymmOperands = {}, 19250 // int -> QUANT16_SYMM map 19251 .quant16SymmOperands = {}, 19252 // int -> FLOAT16 map 19253 .float16Operands = {}, 19254 // int -> BOOL8 map 19255 .bool8Operands = {}, 19256 // int -> QUANT8_SYMM_PER_CHANNEL map 19257 .quant8ChannelOperands = {}, 19258 // int -> QUANT16_ASYMM map 19259 .quant16AsymmOperands = {}, 19260 // int -> QUANT8_SYMM map 19261 .quant8SymmOperands = {}, 19262 } 19263 }, 19264 }, // End of an example 19265 }; 19266 return examples_nchw_weight_as_input_4; 19267 }; 19268 19269 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_4() { 19270 static std::vector<MixedTypedExample> examples_nchw_relaxed_4 = { 19271 // Begin of an example 19272 { 19273 .operands = { 19274 //Input(s) 19275 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19276 // int -> Dimensions map 19277 .operandDimensions = {{0, {1, 2, 4, 4}}}, 19278 // int -> FLOAT32 map 19279 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 19280 // int -> INT32 map 19281 .int32Operands = {}, 19282 // int -> QUANT8_ASYMM map 19283 .quant8AsymmOperands = {}, 19284 // int -> QUANT16_SYMM map 19285 .quant16SymmOperands = {}, 19286 // int -> FLOAT16 map 19287 .float16Operands = {}, 19288 // int -> BOOL8 map 19289 .bool8Operands = {}, 19290 // int -> QUANT8_SYMM_PER_CHANNEL map 19291 .quant8ChannelOperands = {}, 19292 // int -> QUANT16_ASYMM map 19293 .quant16AsymmOperands = {}, 19294 // int -> QUANT8_SYMM map 19295 .quant8SymmOperands = {}, 19296 }, 19297 //Output(s) 19298 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19299 // int -> Dimensions map 19300 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19301 // int -> FLOAT32 map 19302 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19303 // int -> INT32 map 19304 .int32Operands = {}, 19305 // int -> QUANT8_ASYMM map 19306 .quant8AsymmOperands = {}, 19307 // int -> QUANT16_SYMM map 19308 .quant16SymmOperands = {}, 19309 // int -> FLOAT16 map 19310 .float16Operands = {}, 19311 // int -> BOOL8 map 19312 .bool8Operands = {}, 19313 // int -> QUANT8_SYMM_PER_CHANNEL map 19314 .quant8ChannelOperands = {}, 19315 // int -> QUANT16_ASYMM map 19316 .quant16AsymmOperands = {}, 19317 // int -> QUANT8_SYMM map 19318 .quant8SymmOperands = {}, 19319 } 19320 }, 19321 }, // End of an example 19322 }; 19323 return examples_nchw_relaxed_4; 19324 }; 19325 19326 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_weight_as_input_4() { 19327 static std::vector<MixedTypedExample> examples_nchw_relaxed_weight_as_input_4 = { 19328 // Begin of an example 19329 { 19330 .operands = { 19331 //Input(s) 19332 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19333 // int -> Dimensions map 19334 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19335 // int -> FLOAT32 map 19336 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19337 // int -> INT32 map 19338 .int32Operands = {}, 19339 // int -> QUANT8_ASYMM map 19340 .quant8AsymmOperands = {}, 19341 // int -> QUANT16_SYMM map 19342 .quant16SymmOperands = {}, 19343 // int -> FLOAT16 map 19344 .float16Operands = {}, 19345 // int -> BOOL8 map 19346 .bool8Operands = {}, 19347 // int -> QUANT8_SYMM_PER_CHANNEL map 19348 .quant8ChannelOperands = {}, 19349 // int -> QUANT16_ASYMM map 19350 .quant16AsymmOperands = {}, 19351 // int -> QUANT8_SYMM map 19352 .quant8SymmOperands = {}, 19353 }, 19354 //Output(s) 19355 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19356 // int -> Dimensions map 19357 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19358 // int -> FLOAT32 map 19359 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19360 // int -> INT32 map 19361 .int32Operands = {}, 19362 // int -> QUANT8_ASYMM map 19363 .quant8AsymmOperands = {}, 19364 // int -> QUANT16_SYMM map 19365 .quant16SymmOperands = {}, 19366 // int -> FLOAT16 map 19367 .float16Operands = {}, 19368 // int -> BOOL8 map 19369 .bool8Operands = {}, 19370 // int -> QUANT8_SYMM_PER_CHANNEL map 19371 .quant8ChannelOperands = {}, 19372 // int -> QUANT16_ASYMM map 19373 .quant16AsymmOperands = {}, 19374 // int -> QUANT8_SYMM map 19375 .quant8SymmOperands = {}, 19376 } 19377 }, 19378 }, // End of an example 19379 }; 19380 return examples_nchw_relaxed_weight_as_input_4; 19381 }; 19382 19383 std::vector<MixedTypedExample>& get_examples_nchw_quant8_4() { 19384 static std::vector<MixedTypedExample> examples_nchw_quant8_4 = { 19385 // Begin of an example 19386 { 19387 .operands = { 19388 //Input(s) 19389 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19390 // int -> Dimensions map 19391 .operandDimensions = {{0, {1, 2, 4, 4}}}, 19392 // int -> FLOAT32 map 19393 .float32Operands = {}, 19394 // int -> INT32 map 19395 .int32Operands = {}, 19396 // int -> QUANT8_ASYMM map 19397 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 19398 // int -> QUANT16_SYMM map 19399 .quant16SymmOperands = {}, 19400 // int -> FLOAT16 map 19401 .float16Operands = {}, 19402 // int -> BOOL8 map 19403 .bool8Operands = {}, 19404 // int -> QUANT8_SYMM_PER_CHANNEL map 19405 .quant8ChannelOperands = {}, 19406 // int -> QUANT16_ASYMM map 19407 .quant16AsymmOperands = {}, 19408 // int -> QUANT8_SYMM map 19409 .quant8SymmOperands = {}, 19410 }, 19411 //Output(s) 19412 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19413 // int -> Dimensions map 19414 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19415 // int -> FLOAT32 map 19416 .float32Operands = {}, 19417 // int -> INT32 map 19418 .int32Operands = {}, 19419 // int -> QUANT8_ASYMM map 19420 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 19421 // int -> QUANT16_SYMM map 19422 .quant16SymmOperands = {}, 19423 // int -> FLOAT16 map 19424 .float16Operands = {}, 19425 // int -> BOOL8 map 19426 .bool8Operands = {}, 19427 // int -> QUANT8_SYMM_PER_CHANNEL map 19428 .quant8ChannelOperands = {}, 19429 // int -> QUANT16_ASYMM map 19430 .quant16AsymmOperands = {}, 19431 // int -> QUANT8_SYMM map 19432 .quant8SymmOperands = {}, 19433 } 19434 }, 19435 }, // End of an example 19436 }; 19437 return examples_nchw_quant8_4; 19438 }; 19439 19440 std::vector<MixedTypedExample>& get_examples_nchw_quant8_weight_as_input_4() { 19441 static std::vector<MixedTypedExample> examples_nchw_quant8_weight_as_input_4 = { 19442 // Begin of an example 19443 { 19444 .operands = { 19445 //Input(s) 19446 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19447 // int -> Dimensions map 19448 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19449 // int -> FLOAT32 map 19450 .float32Operands = {}, 19451 // int -> INT32 map 19452 .int32Operands = {{2, {0}}}, 19453 // int -> QUANT8_ASYMM map 19454 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}, {1, {132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200}}}, 19455 // int -> QUANT16_SYMM map 19456 .quant16SymmOperands = {}, 19457 // int -> FLOAT16 map 19458 .float16Operands = {}, 19459 // int -> BOOL8 map 19460 .bool8Operands = {}, 19461 // int -> QUANT8_SYMM_PER_CHANNEL map 19462 .quant8ChannelOperands = {}, 19463 // int -> QUANT16_ASYMM map 19464 .quant16AsymmOperands = {}, 19465 // int -> QUANT8_SYMM map 19466 .quant8SymmOperands = {}, 19467 }, 19468 //Output(s) 19469 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19470 // int -> Dimensions map 19471 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19472 // int -> FLOAT32 map 19473 .float32Operands = {}, 19474 // int -> INT32 map 19475 .int32Operands = {}, 19476 // int -> QUANT8_ASYMM map 19477 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 19478 // int -> QUANT16_SYMM map 19479 .quant16SymmOperands = {}, 19480 // int -> FLOAT16 map 19481 .float16Operands = {}, 19482 // int -> BOOL8 map 19483 .bool8Operands = {}, 19484 // int -> QUANT8_SYMM_PER_CHANNEL map 19485 .quant8ChannelOperands = {}, 19486 // int -> QUANT16_ASYMM map 19487 .quant16AsymmOperands = {}, 19488 // int -> QUANT8_SYMM map 19489 .quant8SymmOperands = {}, 19490 } 19491 }, 19492 }, // End of an example 19493 }; 19494 return examples_nchw_quant8_weight_as_input_4; 19495 }; 19496 19497 std::vector<MixedTypedExample>& get_examples_nchw_float16_4() { 19498 static std::vector<MixedTypedExample> examples_nchw_float16_4 = { 19499 // Begin of an example 19500 { 19501 .operands = { 19502 //Input(s) 19503 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19504 // int -> Dimensions map 19505 .operandDimensions = {{0, {1, 2, 4, 4}}}, 19506 // int -> FLOAT32 map 19507 .float32Operands = {}, 19508 // int -> INT32 map 19509 .int32Operands = {}, 19510 // int -> QUANT8_ASYMM map 19511 .quant8AsymmOperands = {}, 19512 // int -> QUANT16_SYMM map 19513 .quant16SymmOperands = {}, 19514 // int -> FLOAT16 map 19515 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 19516 // int -> BOOL8 map 19517 .bool8Operands = {}, 19518 // int -> QUANT8_SYMM_PER_CHANNEL map 19519 .quant8ChannelOperands = {}, 19520 // int -> QUANT16_ASYMM map 19521 .quant16AsymmOperands = {}, 19522 // int -> QUANT8_SYMM map 19523 .quant8SymmOperands = {}, 19524 }, 19525 //Output(s) 19526 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19527 // int -> Dimensions map 19528 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19529 // int -> FLOAT32 map 19530 .float32Operands = {}, 19531 // int -> INT32 map 19532 .int32Operands = {}, 19533 // int -> QUANT8_ASYMM map 19534 .quant8AsymmOperands = {}, 19535 // int -> QUANT16_SYMM map 19536 .quant16SymmOperands = {}, 19537 // int -> FLOAT16 map 19538 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19539 // int -> BOOL8 map 19540 .bool8Operands = {}, 19541 // int -> QUANT8_SYMM_PER_CHANNEL map 19542 .quant8ChannelOperands = {}, 19543 // int -> QUANT16_ASYMM map 19544 .quant16AsymmOperands = {}, 19545 // int -> QUANT8_SYMM map 19546 .quant8SymmOperands = {}, 19547 } 19548 }, 19549 }, // End of an example 19550 }; 19551 return examples_nchw_float16_4; 19552 }; 19553 19554 std::vector<MixedTypedExample>& get_examples_nchw_float16_weight_as_input_4() { 19555 static std::vector<MixedTypedExample> examples_nchw_float16_weight_as_input_4 = { 19556 // Begin of an example 19557 { 19558 .operands = { 19559 //Input(s) 19560 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19561 // int -> Dimensions map 19562 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19563 // int -> FLOAT32 map 19564 .float32Operands = {}, 19565 // int -> INT32 map 19566 .int32Operands = {}, 19567 // int -> QUANT8_ASYMM map 19568 .quant8AsymmOperands = {}, 19569 // int -> QUANT16_SYMM map 19570 .quant16SymmOperands = {}, 19571 // int -> FLOAT16 map 19572 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19573 // int -> BOOL8 map 19574 .bool8Operands = {}, 19575 // int -> QUANT8_SYMM_PER_CHANNEL map 19576 .quant8ChannelOperands = {}, 19577 // int -> QUANT16_ASYMM map 19578 .quant16AsymmOperands = {}, 19579 // int -> QUANT8_SYMM map 19580 .quant8SymmOperands = {}, 19581 }, 19582 //Output(s) 19583 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19584 // int -> Dimensions map 19585 .operandDimensions = {{0, {1, 1, 3, 3}}}, 19586 // int -> FLOAT32 map 19587 .float32Operands = {}, 19588 // int -> INT32 map 19589 .int32Operands = {}, 19590 // int -> QUANT8_ASYMM map 19591 .quant8AsymmOperands = {}, 19592 // int -> QUANT16_SYMM map 19593 .quant16SymmOperands = {}, 19594 // int -> FLOAT16 map 19595 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19596 // int -> BOOL8 map 19597 .bool8Operands = {}, 19598 // int -> QUANT8_SYMM_PER_CHANNEL map 19599 .quant8ChannelOperands = {}, 19600 // int -> QUANT16_ASYMM map 19601 .quant16AsymmOperands = {}, 19602 // int -> QUANT8_SYMM map 19603 .quant8SymmOperands = {}, 19604 } 19605 }, 19606 }, // End of an example 19607 }; 19608 return examples_nchw_float16_weight_as_input_4; 19609 }; 19610 19611 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_4() { 19612 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_4 = { 19613 // Begin of an example 19614 { 19615 .operands = { 19616 //Input(s) 19617 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19618 // int -> Dimensions map 19619 .operandDimensions = {{0, {1, 4, 4, 2}}}, 19620 // int -> FLOAT32 map 19621 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 19622 // int -> INT32 map 19623 .int32Operands = {}, 19624 // int -> QUANT8_ASYMM map 19625 .quant8AsymmOperands = {}, 19626 // int -> QUANT16_SYMM map 19627 .quant16SymmOperands = {}, 19628 // int -> FLOAT16 map 19629 .float16Operands = {}, 19630 // int -> BOOL8 map 19631 .bool8Operands = {}, 19632 // int -> QUANT8_SYMM_PER_CHANNEL map 19633 .quant8ChannelOperands = {}, 19634 // int -> QUANT16_ASYMM map 19635 .quant16AsymmOperands = {}, 19636 // int -> QUANT8_SYMM map 19637 .quant8SymmOperands = {}, 19638 }, 19639 //Output(s) 19640 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19641 // int -> Dimensions map 19642 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19643 // int -> FLOAT32 map 19644 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19645 // int -> INT32 map 19646 .int32Operands = {}, 19647 // int -> QUANT8_ASYMM map 19648 .quant8AsymmOperands = {}, 19649 // int -> QUANT16_SYMM map 19650 .quant16SymmOperands = {}, 19651 // int -> FLOAT16 map 19652 .float16Operands = {}, 19653 // int -> BOOL8 map 19654 .bool8Operands = {}, 19655 // int -> QUANT8_SYMM_PER_CHANNEL map 19656 .quant8ChannelOperands = {}, 19657 // int -> QUANT16_ASYMM map 19658 .quant16AsymmOperands = {}, 19659 // int -> QUANT8_SYMM map 19660 .quant8SymmOperands = {}, 19661 } 19662 }, 19663 }, // End of an example 19664 }; 19665 return examples_dynamic_output_shape_nhwc_4; 19666 }; 19667 19668 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_4() { 19669 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_4 = { 19670 // Begin of an example 19671 { 19672 .operands = { 19673 //Input(s) 19674 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19675 // int -> Dimensions map 19676 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19677 // int -> FLOAT32 map 19678 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19679 // int -> INT32 map 19680 .int32Operands = {}, 19681 // int -> QUANT8_ASYMM map 19682 .quant8AsymmOperands = {}, 19683 // int -> QUANT16_SYMM map 19684 .quant16SymmOperands = {}, 19685 // int -> FLOAT16 map 19686 .float16Operands = {}, 19687 // int -> BOOL8 map 19688 .bool8Operands = {}, 19689 // int -> QUANT8_SYMM_PER_CHANNEL map 19690 .quant8ChannelOperands = {}, 19691 // int -> QUANT16_ASYMM map 19692 .quant16AsymmOperands = {}, 19693 // int -> QUANT8_SYMM map 19694 .quant8SymmOperands = {}, 19695 }, 19696 //Output(s) 19697 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19698 // int -> Dimensions map 19699 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19700 // int -> FLOAT32 map 19701 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19702 // int -> INT32 map 19703 .int32Operands = {}, 19704 // int -> QUANT8_ASYMM map 19705 .quant8AsymmOperands = {}, 19706 // int -> QUANT16_SYMM map 19707 .quant16SymmOperands = {}, 19708 // int -> FLOAT16 map 19709 .float16Operands = {}, 19710 // int -> BOOL8 map 19711 .bool8Operands = {}, 19712 // int -> QUANT8_SYMM_PER_CHANNEL map 19713 .quant8ChannelOperands = {}, 19714 // int -> QUANT16_ASYMM map 19715 .quant16AsymmOperands = {}, 19716 // int -> QUANT8_SYMM map 19717 .quant8SymmOperands = {}, 19718 } 19719 }, 19720 }, // End of an example 19721 }; 19722 return examples_dynamic_output_shape_nhwc_weight_as_input_4; 19723 }; 19724 19725 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_4() { 19726 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_4 = { 19727 // Begin of an example 19728 { 19729 .operands = { 19730 //Input(s) 19731 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19732 // int -> Dimensions map 19733 .operandDimensions = {{0, {1, 4, 4, 2}}}, 19734 // int -> FLOAT32 map 19735 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 19736 // int -> INT32 map 19737 .int32Operands = {}, 19738 // int -> QUANT8_ASYMM map 19739 .quant8AsymmOperands = {}, 19740 // int -> QUANT16_SYMM map 19741 .quant16SymmOperands = {}, 19742 // int -> FLOAT16 map 19743 .float16Operands = {}, 19744 // int -> BOOL8 map 19745 .bool8Operands = {}, 19746 // int -> QUANT8_SYMM_PER_CHANNEL map 19747 .quant8ChannelOperands = {}, 19748 // int -> QUANT16_ASYMM map 19749 .quant16AsymmOperands = {}, 19750 // int -> QUANT8_SYMM map 19751 .quant8SymmOperands = {}, 19752 }, 19753 //Output(s) 19754 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19755 // int -> Dimensions map 19756 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19757 // int -> FLOAT32 map 19758 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19759 // int -> INT32 map 19760 .int32Operands = {}, 19761 // int -> QUANT8_ASYMM map 19762 .quant8AsymmOperands = {}, 19763 // int -> QUANT16_SYMM map 19764 .quant16SymmOperands = {}, 19765 // int -> FLOAT16 map 19766 .float16Operands = {}, 19767 // int -> BOOL8 map 19768 .bool8Operands = {}, 19769 // int -> QUANT8_SYMM_PER_CHANNEL map 19770 .quant8ChannelOperands = {}, 19771 // int -> QUANT16_ASYMM map 19772 .quant16AsymmOperands = {}, 19773 // int -> QUANT8_SYMM map 19774 .quant8SymmOperands = {}, 19775 } 19776 }, 19777 }, // End of an example 19778 }; 19779 return examples_dynamic_output_shape_nhwc_relaxed_4; 19780 }; 19781 19782 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_4() { 19783 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_4 = { 19784 // Begin of an example 19785 { 19786 .operands = { 19787 //Input(s) 19788 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19789 // int -> Dimensions map 19790 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19791 // int -> FLOAT32 map 19792 .float32Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 19793 // int -> INT32 map 19794 .int32Operands = {}, 19795 // int -> QUANT8_ASYMM map 19796 .quant8AsymmOperands = {}, 19797 // int -> QUANT16_SYMM map 19798 .quant16SymmOperands = {}, 19799 // int -> FLOAT16 map 19800 .float16Operands = {}, 19801 // int -> BOOL8 map 19802 .bool8Operands = {}, 19803 // int -> QUANT8_SYMM_PER_CHANNEL map 19804 .quant8ChannelOperands = {}, 19805 // int -> QUANT16_ASYMM map 19806 .quant16AsymmOperands = {}, 19807 // int -> QUANT8_SYMM map 19808 .quant8SymmOperands = {}, 19809 }, 19810 //Output(s) 19811 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19812 // int -> Dimensions map 19813 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19814 // int -> FLOAT32 map 19815 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19816 // int -> INT32 map 19817 .int32Operands = {}, 19818 // int -> QUANT8_ASYMM map 19819 .quant8AsymmOperands = {}, 19820 // int -> QUANT16_SYMM map 19821 .quant16SymmOperands = {}, 19822 // int -> FLOAT16 map 19823 .float16Operands = {}, 19824 // int -> BOOL8 map 19825 .bool8Operands = {}, 19826 // int -> QUANT8_SYMM_PER_CHANNEL map 19827 .quant8ChannelOperands = {}, 19828 // int -> QUANT16_ASYMM map 19829 .quant16AsymmOperands = {}, 19830 // int -> QUANT8_SYMM map 19831 .quant8SymmOperands = {}, 19832 } 19833 }, 19834 }, // End of an example 19835 }; 19836 return examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_4; 19837 }; 19838 19839 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_4() { 19840 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_4 = { 19841 // Begin of an example 19842 { 19843 .operands = { 19844 //Input(s) 19845 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19846 // int -> Dimensions map 19847 .operandDimensions = {{0, {1, 4, 4, 2}}}, 19848 // int -> FLOAT32 map 19849 .float32Operands = {}, 19850 // int -> INT32 map 19851 .int32Operands = {}, 19852 // int -> QUANT8_ASYMM map 19853 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}}, 19854 // int -> QUANT16_SYMM map 19855 .quant16SymmOperands = {}, 19856 // int -> FLOAT16 map 19857 .float16Operands = {}, 19858 // int -> BOOL8 map 19859 .bool8Operands = {}, 19860 // int -> QUANT8_SYMM_PER_CHANNEL map 19861 .quant8ChannelOperands = {}, 19862 // int -> QUANT16_ASYMM map 19863 .quant16AsymmOperands = {}, 19864 // int -> QUANT8_SYMM map 19865 .quant8SymmOperands = {}, 19866 }, 19867 //Output(s) 19868 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19869 // int -> Dimensions map 19870 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19871 // int -> FLOAT32 map 19872 .float32Operands = {}, 19873 // int -> INT32 map 19874 .int32Operands = {}, 19875 // int -> QUANT8_ASYMM map 19876 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 19877 // int -> QUANT16_SYMM map 19878 .quant16SymmOperands = {}, 19879 // int -> FLOAT16 map 19880 .float16Operands = {}, 19881 // int -> BOOL8 map 19882 .bool8Operands = {}, 19883 // int -> QUANT8_SYMM_PER_CHANNEL map 19884 .quant8ChannelOperands = {}, 19885 // int -> QUANT16_ASYMM map 19886 .quant16AsymmOperands = {}, 19887 // int -> QUANT8_SYMM map 19888 .quant8SymmOperands = {}, 19889 } 19890 }, 19891 }, // End of an example 19892 }; 19893 return examples_dynamic_output_shape_nhwc_quant8_4; 19894 }; 19895 19896 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_weight_as_input_4() { 19897 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_weight_as_input_4 = { 19898 // Begin of an example 19899 { 19900 .operands = { 19901 //Input(s) 19902 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19903 // int -> Dimensions map 19904 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 19905 // int -> FLOAT32 map 19906 .float32Operands = {}, 19907 // int -> INT32 map 19908 .int32Operands = {{2, {0}}}, 19909 // int -> QUANT8_ASYMM map 19910 .quant8AsymmOperands = {{0, {102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164}}, {1, {132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200}}}, 19911 // int -> QUANT16_SYMM map 19912 .quant16SymmOperands = {}, 19913 // int -> FLOAT16 map 19914 .float16Operands = {}, 19915 // int -> BOOL8 map 19916 .bool8Operands = {}, 19917 // int -> QUANT8_SYMM_PER_CHANNEL map 19918 .quant8ChannelOperands = {}, 19919 // int -> QUANT16_ASYMM map 19920 .quant16AsymmOperands = {}, 19921 // int -> QUANT8_SYMM map 19922 .quant8SymmOperands = {}, 19923 }, 19924 //Output(s) 19925 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19926 // int -> Dimensions map 19927 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19928 // int -> FLOAT32 map 19929 .float32Operands = {}, 19930 // int -> INT32 map 19931 .int32Operands = {}, 19932 // int -> QUANT8_ASYMM map 19933 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 19934 // int -> QUANT16_SYMM map 19935 .quant16SymmOperands = {}, 19936 // int -> FLOAT16 map 19937 .float16Operands = {}, 19938 // int -> BOOL8 map 19939 .bool8Operands = {}, 19940 // int -> QUANT8_SYMM_PER_CHANNEL map 19941 .quant8ChannelOperands = {}, 19942 // int -> QUANT16_ASYMM map 19943 .quant16AsymmOperands = {}, 19944 // int -> QUANT8_SYMM map 19945 .quant8SymmOperands = {}, 19946 } 19947 }, 19948 }, // End of an example 19949 }; 19950 return examples_dynamic_output_shape_nhwc_quant8_weight_as_input_4; 19951 }; 19952 19953 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_4() { 19954 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_4 = { 19955 // Begin of an example 19956 { 19957 .operands = { 19958 //Input(s) 19959 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19960 // int -> Dimensions map 19961 .operandDimensions = {{0, {1, 4, 4, 2}}}, 19962 // int -> FLOAT32 map 19963 .float32Operands = {}, 19964 // int -> INT32 map 19965 .int32Operands = {}, 19966 // int -> QUANT8_ASYMM map 19967 .quant8AsymmOperands = {}, 19968 // int -> QUANT16_SYMM map 19969 .quant16SymmOperands = {}, 19970 // int -> FLOAT16 map 19971 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f}}}, 19972 // int -> BOOL8 map 19973 .bool8Operands = {}, 19974 // int -> QUANT8_SYMM_PER_CHANNEL map 19975 .quant8ChannelOperands = {}, 19976 // int -> QUANT16_ASYMM map 19977 .quant16AsymmOperands = {}, 19978 // int -> QUANT8_SYMM map 19979 .quant8SymmOperands = {}, 19980 }, 19981 //Output(s) 19982 { // See tools/test_generator/include/TestHarness.h:MixedTyped 19983 // int -> Dimensions map 19984 .operandDimensions = {{0, {1, 3, 3, 1}}}, 19985 // int -> FLOAT32 map 19986 .float32Operands = {}, 19987 // int -> INT32 map 19988 .int32Operands = {}, 19989 // int -> QUANT8_ASYMM map 19990 .quant8AsymmOperands = {}, 19991 // int -> QUANT16_SYMM map 19992 .quant16SymmOperands = {}, 19993 // int -> FLOAT16 map 19994 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 19995 // int -> BOOL8 map 19996 .bool8Operands = {}, 19997 // int -> QUANT8_SYMM_PER_CHANNEL map 19998 .quant8ChannelOperands = {}, 19999 // int -> QUANT16_ASYMM map 20000 .quant16AsymmOperands = {}, 20001 // int -> QUANT8_SYMM map 20002 .quant8SymmOperands = {}, 20003 } 20004 }, 20005 }, // End of an example 20006 }; 20007 return examples_dynamic_output_shape_nhwc_float16_4; 20008 }; 20009 20010 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_weight_as_input_4() { 20011 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_weight_as_input_4 = { 20012 // Begin of an example 20013 { 20014 .operands = { 20015 //Input(s) 20016 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20017 // int -> Dimensions map 20018 .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 20019 // int -> FLOAT32 map 20020 .float32Operands = {}, 20021 // int -> INT32 map 20022 .int32Operands = {}, 20023 // int -> QUANT8_ASYMM map 20024 .quant8AsymmOperands = {}, 20025 // int -> QUANT16_SYMM map 20026 .quant16SymmOperands = {}, 20027 // int -> FLOAT16 map 20028 .float16Operands = {{0, {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, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 20029 // int -> BOOL8 map 20030 .bool8Operands = {}, 20031 // int -> QUANT8_SYMM_PER_CHANNEL map 20032 .quant8ChannelOperands = {}, 20033 // int -> QUANT16_ASYMM map 20034 .quant16AsymmOperands = {}, 20035 // int -> QUANT8_SYMM map 20036 .quant8SymmOperands = {}, 20037 }, 20038 //Output(s) 20039 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20040 // int -> Dimensions map 20041 .operandDimensions = {{0, {1, 3, 3, 1}}}, 20042 // int -> FLOAT32 map 20043 .float32Operands = {}, 20044 // int -> INT32 map 20045 .int32Operands = {}, 20046 // int -> QUANT8_ASYMM map 20047 .quant8AsymmOperands = {}, 20048 // int -> QUANT16_SYMM map 20049 .quant16SymmOperands = {}, 20050 // int -> FLOAT16 map 20051 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20052 // int -> BOOL8 map 20053 .bool8Operands = {}, 20054 // int -> QUANT8_SYMM_PER_CHANNEL map 20055 .quant8ChannelOperands = {}, 20056 // int -> QUANT16_ASYMM map 20057 .quant16AsymmOperands = {}, 20058 // int -> QUANT8_SYMM map 20059 .quant8SymmOperands = {}, 20060 } 20061 }, 20062 }, // End of an example 20063 }; 20064 return examples_dynamic_output_shape_nhwc_float16_weight_as_input_4; 20065 }; 20066 20067 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_4() { 20068 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_4 = { 20069 // Begin of an example 20070 { 20071 .operands = { 20072 //Input(s) 20073 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20074 // int -> Dimensions map 20075 .operandDimensions = {{0, {1, 2, 4, 4}}}, 20076 // int -> FLOAT32 map 20077 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 20078 // int -> INT32 map 20079 .int32Operands = {}, 20080 // int -> QUANT8_ASYMM map 20081 .quant8AsymmOperands = {}, 20082 // int -> QUANT16_SYMM map 20083 .quant16SymmOperands = {}, 20084 // int -> FLOAT16 map 20085 .float16Operands = {}, 20086 // int -> BOOL8 map 20087 .bool8Operands = {}, 20088 // int -> QUANT8_SYMM_PER_CHANNEL map 20089 .quant8ChannelOperands = {}, 20090 // int -> QUANT16_ASYMM map 20091 .quant16AsymmOperands = {}, 20092 // int -> QUANT8_SYMM map 20093 .quant8SymmOperands = {}, 20094 }, 20095 //Output(s) 20096 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20097 // int -> Dimensions map 20098 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20099 // int -> FLOAT32 map 20100 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20101 // int -> INT32 map 20102 .int32Operands = {}, 20103 // int -> QUANT8_ASYMM map 20104 .quant8AsymmOperands = {}, 20105 // int -> QUANT16_SYMM map 20106 .quant16SymmOperands = {}, 20107 // int -> FLOAT16 map 20108 .float16Operands = {}, 20109 // int -> BOOL8 map 20110 .bool8Operands = {}, 20111 // int -> QUANT8_SYMM_PER_CHANNEL map 20112 .quant8ChannelOperands = {}, 20113 // int -> QUANT16_ASYMM map 20114 .quant16AsymmOperands = {}, 20115 // int -> QUANT8_SYMM map 20116 .quant8SymmOperands = {}, 20117 } 20118 }, 20119 }, // End of an example 20120 }; 20121 return examples_dynamic_output_shape_nchw_4; 20122 }; 20123 20124 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_4() { 20125 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_4 = { 20126 // Begin of an example 20127 { 20128 .operands = { 20129 //Input(s) 20130 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20131 // int -> Dimensions map 20132 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 20133 // int -> FLOAT32 map 20134 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 20135 // int -> INT32 map 20136 .int32Operands = {}, 20137 // int -> QUANT8_ASYMM map 20138 .quant8AsymmOperands = {}, 20139 // int -> QUANT16_SYMM map 20140 .quant16SymmOperands = {}, 20141 // int -> FLOAT16 map 20142 .float16Operands = {}, 20143 // int -> BOOL8 map 20144 .bool8Operands = {}, 20145 // int -> QUANT8_SYMM_PER_CHANNEL map 20146 .quant8ChannelOperands = {}, 20147 // int -> QUANT16_ASYMM map 20148 .quant16AsymmOperands = {}, 20149 // int -> QUANT8_SYMM map 20150 .quant8SymmOperands = {}, 20151 }, 20152 //Output(s) 20153 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20154 // int -> Dimensions map 20155 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20156 // int -> FLOAT32 map 20157 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20158 // int -> INT32 map 20159 .int32Operands = {}, 20160 // int -> QUANT8_ASYMM map 20161 .quant8AsymmOperands = {}, 20162 // int -> QUANT16_SYMM map 20163 .quant16SymmOperands = {}, 20164 // int -> FLOAT16 map 20165 .float16Operands = {}, 20166 // int -> BOOL8 map 20167 .bool8Operands = {}, 20168 // int -> QUANT8_SYMM_PER_CHANNEL map 20169 .quant8ChannelOperands = {}, 20170 // int -> QUANT16_ASYMM map 20171 .quant16AsymmOperands = {}, 20172 // int -> QUANT8_SYMM map 20173 .quant8SymmOperands = {}, 20174 } 20175 }, 20176 }, // End of an example 20177 }; 20178 return examples_dynamic_output_shape_nchw_weight_as_input_4; 20179 }; 20180 20181 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_4() { 20182 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_4 = { 20183 // Begin of an example 20184 { 20185 .operands = { 20186 //Input(s) 20187 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20188 // int -> Dimensions map 20189 .operandDimensions = {{0, {1, 2, 4, 4}}}, 20190 // int -> FLOAT32 map 20191 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 20192 // int -> INT32 map 20193 .int32Operands = {}, 20194 // int -> QUANT8_ASYMM map 20195 .quant8AsymmOperands = {}, 20196 // int -> QUANT16_SYMM map 20197 .quant16SymmOperands = {}, 20198 // int -> FLOAT16 map 20199 .float16Operands = {}, 20200 // int -> BOOL8 map 20201 .bool8Operands = {}, 20202 // int -> QUANT8_SYMM_PER_CHANNEL map 20203 .quant8ChannelOperands = {}, 20204 // int -> QUANT16_ASYMM map 20205 .quant16AsymmOperands = {}, 20206 // int -> QUANT8_SYMM map 20207 .quant8SymmOperands = {}, 20208 }, 20209 //Output(s) 20210 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20211 // int -> Dimensions map 20212 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20213 // int -> FLOAT32 map 20214 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20215 // int -> INT32 map 20216 .int32Operands = {}, 20217 // int -> QUANT8_ASYMM map 20218 .quant8AsymmOperands = {}, 20219 // int -> QUANT16_SYMM map 20220 .quant16SymmOperands = {}, 20221 // int -> FLOAT16 map 20222 .float16Operands = {}, 20223 // int -> BOOL8 map 20224 .bool8Operands = {}, 20225 // int -> QUANT8_SYMM_PER_CHANNEL map 20226 .quant8ChannelOperands = {}, 20227 // int -> QUANT16_ASYMM map 20228 .quant16AsymmOperands = {}, 20229 // int -> QUANT8_SYMM map 20230 .quant8SymmOperands = {}, 20231 } 20232 }, 20233 }, // End of an example 20234 }; 20235 return examples_dynamic_output_shape_nchw_relaxed_4; 20236 }; 20237 20238 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_weight_as_input_4() { 20239 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_weight_as_input_4 = { 20240 // Begin of an example 20241 { 20242 .operands = { 20243 //Input(s) 20244 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20245 // int -> Dimensions map 20246 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 20247 // int -> FLOAT32 map 20248 .float32Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 20249 // int -> INT32 map 20250 .int32Operands = {}, 20251 // int -> QUANT8_ASYMM map 20252 .quant8AsymmOperands = {}, 20253 // int -> QUANT16_SYMM map 20254 .quant16SymmOperands = {}, 20255 // int -> FLOAT16 map 20256 .float16Operands = {}, 20257 // int -> BOOL8 map 20258 .bool8Operands = {}, 20259 // int -> QUANT8_SYMM_PER_CHANNEL map 20260 .quant8ChannelOperands = {}, 20261 // int -> QUANT16_ASYMM map 20262 .quant16AsymmOperands = {}, 20263 // int -> QUANT8_SYMM map 20264 .quant8SymmOperands = {}, 20265 }, 20266 //Output(s) 20267 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20268 // int -> Dimensions map 20269 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20270 // int -> FLOAT32 map 20271 .float32Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20272 // int -> INT32 map 20273 .int32Operands = {}, 20274 // int -> QUANT8_ASYMM map 20275 .quant8AsymmOperands = {}, 20276 // int -> QUANT16_SYMM map 20277 .quant16SymmOperands = {}, 20278 // int -> FLOAT16 map 20279 .float16Operands = {}, 20280 // int -> BOOL8 map 20281 .bool8Operands = {}, 20282 // int -> QUANT8_SYMM_PER_CHANNEL map 20283 .quant8ChannelOperands = {}, 20284 // int -> QUANT16_ASYMM map 20285 .quant16AsymmOperands = {}, 20286 // int -> QUANT8_SYMM map 20287 .quant8SymmOperands = {}, 20288 } 20289 }, 20290 }, // End of an example 20291 }; 20292 return examples_dynamic_output_shape_nchw_relaxed_weight_as_input_4; 20293 }; 20294 20295 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_4() { 20296 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_4 = { 20297 // Begin of an example 20298 { 20299 .operands = { 20300 //Input(s) 20301 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20302 // int -> Dimensions map 20303 .operandDimensions = {{0, {1, 2, 4, 4}}}, 20304 // int -> FLOAT32 map 20305 .float32Operands = {}, 20306 // int -> INT32 map 20307 .int32Operands = {}, 20308 // int -> QUANT8_ASYMM map 20309 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}}, 20310 // int -> QUANT16_SYMM map 20311 .quant16SymmOperands = {}, 20312 // int -> FLOAT16 map 20313 .float16Operands = {}, 20314 // int -> BOOL8 map 20315 .bool8Operands = {}, 20316 // int -> QUANT8_SYMM_PER_CHANNEL map 20317 .quant8ChannelOperands = {}, 20318 // int -> QUANT16_ASYMM map 20319 .quant16AsymmOperands = {}, 20320 // int -> QUANT8_SYMM map 20321 .quant8SymmOperands = {}, 20322 }, 20323 //Output(s) 20324 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20325 // int -> Dimensions map 20326 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20327 // int -> FLOAT32 map 20328 .float32Operands = {}, 20329 // int -> INT32 map 20330 .int32Operands = {}, 20331 // int -> QUANT8_ASYMM map 20332 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 20333 // int -> QUANT16_SYMM map 20334 .quant16SymmOperands = {}, 20335 // int -> FLOAT16 map 20336 .float16Operands = {}, 20337 // int -> BOOL8 map 20338 .bool8Operands = {}, 20339 // int -> QUANT8_SYMM_PER_CHANNEL map 20340 .quant8ChannelOperands = {}, 20341 // int -> QUANT16_ASYMM map 20342 .quant16AsymmOperands = {}, 20343 // int -> QUANT8_SYMM map 20344 .quant8SymmOperands = {}, 20345 } 20346 }, 20347 }, // End of an example 20348 }; 20349 return examples_dynamic_output_shape_nchw_quant8_4; 20350 }; 20351 20352 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_weight_as_input_4() { 20353 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_weight_as_input_4 = { 20354 // Begin of an example 20355 { 20356 .operands = { 20357 //Input(s) 20358 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20359 // int -> Dimensions map 20360 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 20361 // int -> FLOAT32 map 20362 .float32Operands = {}, 20363 // int -> INT32 map 20364 .int32Operands = {{2, {0}}}, 20365 // int -> QUANT8_ASYMM map 20366 .quant8AsymmOperands = {{0, {102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164}}, {1, {132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200}}}, 20367 // int -> QUANT16_SYMM map 20368 .quant16SymmOperands = {}, 20369 // int -> FLOAT16 map 20370 .float16Operands = {}, 20371 // int -> BOOL8 map 20372 .bool8Operands = {}, 20373 // int -> QUANT8_SYMM_PER_CHANNEL map 20374 .quant8ChannelOperands = {}, 20375 // int -> QUANT16_ASYMM map 20376 .quant16AsymmOperands = {}, 20377 // int -> QUANT8_SYMM map 20378 .quant8SymmOperands = {}, 20379 }, 20380 //Output(s) 20381 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20382 // int -> Dimensions map 20383 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20384 // int -> FLOAT32 map 20385 .float32Operands = {}, 20386 // int -> INT32 map 20387 .int32Operands = {}, 20388 // int -> QUANT8_ASYMM map 20389 .quant8AsymmOperands = {{0, {84, 117, 134, 125, 186, 203, 148, 218, 233}}}, 20390 // int -> QUANT16_SYMM map 20391 .quant16SymmOperands = {}, 20392 // int -> FLOAT16 map 20393 .float16Operands = {}, 20394 // int -> BOOL8 map 20395 .bool8Operands = {}, 20396 // int -> QUANT8_SYMM_PER_CHANNEL map 20397 .quant8ChannelOperands = {}, 20398 // int -> QUANT16_ASYMM map 20399 .quant16AsymmOperands = {}, 20400 // int -> QUANT8_SYMM map 20401 .quant8SymmOperands = {}, 20402 } 20403 }, 20404 }, // End of an example 20405 }; 20406 return examples_dynamic_output_shape_nchw_quant8_weight_as_input_4; 20407 }; 20408 20409 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_4() { 20410 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_4 = { 20411 // Begin of an example 20412 { 20413 .operands = { 20414 //Input(s) 20415 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20416 // int -> Dimensions map 20417 .operandDimensions = {{0, {1, 2, 4, 4}}}, 20418 // int -> FLOAT32 map 20419 .float32Operands = {}, 20420 // int -> INT32 map 20421 .int32Operands = {}, 20422 // int -> QUANT8_ASYMM map 20423 .quant8AsymmOperands = {}, 20424 // int -> QUANT16_SYMM map 20425 .quant16SymmOperands = {}, 20426 // int -> FLOAT16 map 20427 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f}}}, 20428 // int -> BOOL8 map 20429 .bool8Operands = {}, 20430 // int -> QUANT8_SYMM_PER_CHANNEL map 20431 .quant8ChannelOperands = {}, 20432 // int -> QUANT16_ASYMM map 20433 .quant16AsymmOperands = {}, 20434 // int -> QUANT8_SYMM map 20435 .quant8SymmOperands = {}, 20436 }, 20437 //Output(s) 20438 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20439 // int -> Dimensions map 20440 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20441 // int -> FLOAT32 map 20442 .float32Operands = {}, 20443 // int -> INT32 map 20444 .int32Operands = {}, 20445 // int -> QUANT8_ASYMM map 20446 .quant8AsymmOperands = {}, 20447 // int -> QUANT16_SYMM map 20448 .quant16SymmOperands = {}, 20449 // int -> FLOAT16 map 20450 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20451 // int -> BOOL8 map 20452 .bool8Operands = {}, 20453 // int -> QUANT8_SYMM_PER_CHANNEL map 20454 .quant8ChannelOperands = {}, 20455 // int -> QUANT16_ASYMM map 20456 .quant16AsymmOperands = {}, 20457 // int -> QUANT8_SYMM map 20458 .quant8SymmOperands = {}, 20459 } 20460 }, 20461 }, // End of an example 20462 }; 20463 return examples_dynamic_output_shape_nchw_float16_4; 20464 }; 20465 20466 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_weight_as_input_4() { 20467 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_weight_as_input_4 = { 20468 // Begin of an example 20469 { 20470 .operands = { 20471 //Input(s) 20472 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20473 // int -> Dimensions map 20474 .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 3, 3, 2}}, {2, {1}}}, 20475 // int -> FLOAT32 map 20476 .float32Operands = {}, 20477 // int -> INT32 map 20478 .int32Operands = {}, 20479 // int -> QUANT8_ASYMM map 20480 .quant8AsymmOperands = {}, 20481 // int -> QUANT16_SYMM map 20482 .quant16SymmOperands = {}, 20483 // int -> FLOAT16 map 20484 .float16Operands = {{0, {1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 13.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 27.0f, 29.0f, 31.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 18.0f, 20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.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, 17.0f, 18.0f}}, {2, {0.0f}}}, 20485 // int -> BOOL8 map 20486 .bool8Operands = {}, 20487 // int -> QUANT8_SYMM_PER_CHANNEL map 20488 .quant8ChannelOperands = {}, 20489 // int -> QUANT16_ASYMM map 20490 .quant16AsymmOperands = {}, 20491 // int -> QUANT8_SYMM map 20492 .quant8SymmOperands = {}, 20493 }, 20494 //Output(s) 20495 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20496 // int -> Dimensions map 20497 .operandDimensions = {{0, {1, 1, 3, 3}}}, 20498 // int -> FLOAT32 map 20499 .float32Operands = {}, 20500 // int -> INT32 map 20501 .int32Operands = {}, 20502 // int -> QUANT8_ASYMM map 20503 .quant8AsymmOperands = {}, 20504 // int -> QUANT16_SYMM map 20505 .quant16SymmOperands = {}, 20506 // int -> FLOAT16 map 20507 .float16Operands = {{0, {678.0f, 1347.0f, 1689.0f, 1494.0f, 2715.0f, 3057.0f, 1968.0f, 3352.0f, 3652.0f}}}, 20508 // int -> BOOL8 map 20509 .bool8Operands = {}, 20510 // int -> QUANT8_SYMM_PER_CHANNEL map 20511 .quant8ChannelOperands = {}, 20512 // int -> QUANT16_ASYMM map 20513 .quant16AsymmOperands = {}, 20514 // int -> QUANT8_SYMM map 20515 .quant8SymmOperands = {}, 20516 } 20517 }, 20518 }, // End of an example 20519 }; 20520 return examples_dynamic_output_shape_nchw_float16_weight_as_input_4; 20521 }; 20522 20523 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc() { 20524 static std::vector<MixedTypedExample> examples_zero_sized_nhwc = { 20525 // Begin of an example 20526 { 20527 .operands = { 20528 //Input(s) 20529 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20530 // int -> Dimensions map 20531 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20532 // int -> FLOAT32 map 20533 .float32Operands = {{0, {1.0f}}}, 20534 // int -> INT32 map 20535 .int32Operands = {}, 20536 // int -> QUANT8_ASYMM map 20537 .quant8AsymmOperands = {}, 20538 // int -> QUANT16_SYMM map 20539 .quant16SymmOperands = {}, 20540 // int -> FLOAT16 map 20541 .float16Operands = {}, 20542 // int -> BOOL8 map 20543 .bool8Operands = {}, 20544 // int -> QUANT8_SYMM_PER_CHANNEL map 20545 .quant8ChannelOperands = {}, 20546 // int -> QUANT16_ASYMM map 20547 .quant16AsymmOperands = {}, 20548 // int -> QUANT8_SYMM map 20549 .quant8SymmOperands = {}, 20550 }, 20551 //Output(s) 20552 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20553 // int -> Dimensions map 20554 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 20555 // int -> FLOAT32 map 20556 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20557 // int -> INT32 map 20558 .int32Operands = {{1, {0}}}, 20559 // int -> QUANT8_ASYMM map 20560 .quant8AsymmOperands = {}, 20561 // int -> QUANT16_SYMM map 20562 .quant16SymmOperands = {}, 20563 // int -> FLOAT16 map 20564 .float16Operands = {}, 20565 // int -> BOOL8 map 20566 .bool8Operands = {}, 20567 // int -> QUANT8_SYMM_PER_CHANNEL map 20568 .quant8ChannelOperands = {}, 20569 // int -> QUANT16_ASYMM map 20570 .quant16AsymmOperands = {}, 20571 // int -> QUANT8_SYMM map 20572 .quant8SymmOperands = {}, 20573 } 20574 }, 20575 }, // End of an example 20576 }; 20577 return examples_zero_sized_nhwc; 20578 }; 20579 20580 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_relaxed() { 20581 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_relaxed = { 20582 // Begin of an example 20583 { 20584 .operands = { 20585 //Input(s) 20586 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20587 // int -> Dimensions map 20588 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20589 // int -> FLOAT32 map 20590 .float32Operands = {{0, {1.0f}}}, 20591 // int -> INT32 map 20592 .int32Operands = {}, 20593 // int -> QUANT8_ASYMM map 20594 .quant8AsymmOperands = {}, 20595 // int -> QUANT16_SYMM map 20596 .quant16SymmOperands = {}, 20597 // int -> FLOAT16 map 20598 .float16Operands = {}, 20599 // int -> BOOL8 map 20600 .bool8Operands = {}, 20601 // int -> QUANT8_SYMM_PER_CHANNEL map 20602 .quant8ChannelOperands = {}, 20603 // int -> QUANT16_ASYMM map 20604 .quant16AsymmOperands = {}, 20605 // int -> QUANT8_SYMM map 20606 .quant8SymmOperands = {}, 20607 }, 20608 //Output(s) 20609 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20610 // int -> Dimensions map 20611 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 20612 // int -> FLOAT32 map 20613 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20614 // int -> INT32 map 20615 .int32Operands = {{1, {0}}}, 20616 // int -> QUANT8_ASYMM map 20617 .quant8AsymmOperands = {}, 20618 // int -> QUANT16_SYMM map 20619 .quant16SymmOperands = {}, 20620 // int -> FLOAT16 map 20621 .float16Operands = {}, 20622 // int -> BOOL8 map 20623 .bool8Operands = {}, 20624 // int -> QUANT8_SYMM_PER_CHANNEL map 20625 .quant8ChannelOperands = {}, 20626 // int -> QUANT16_ASYMM map 20627 .quant16AsymmOperands = {}, 20628 // int -> QUANT8_SYMM map 20629 .quant8SymmOperands = {}, 20630 } 20631 }, 20632 }, // End of an example 20633 }; 20634 return examples_zero_sized_nhwc_relaxed; 20635 }; 20636 20637 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_quant8() { 20638 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_quant8 = { 20639 // Begin of an example 20640 { 20641 .operands = { 20642 //Input(s) 20643 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20644 // int -> Dimensions map 20645 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20646 // int -> FLOAT32 map 20647 .float32Operands = {}, 20648 // int -> INT32 map 20649 .int32Operands = {}, 20650 // int -> QUANT8_ASYMM map 20651 .quant8AsymmOperands = {{0, {138}}}, 20652 // int -> QUANT16_SYMM map 20653 .quant16SymmOperands = {}, 20654 // int -> FLOAT16 map 20655 .float16Operands = {}, 20656 // int -> BOOL8 map 20657 .bool8Operands = {}, 20658 // int -> QUANT8_SYMM_PER_CHANNEL map 20659 .quant8ChannelOperands = {}, 20660 // int -> QUANT16_ASYMM map 20661 .quant16AsymmOperands = {}, 20662 // int -> QUANT8_SYMM map 20663 .quant8SymmOperands = {}, 20664 }, 20665 //Output(s) 20666 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20667 // int -> Dimensions map 20668 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 20669 // int -> FLOAT32 map 20670 .float32Operands = {}, 20671 // int -> INT32 map 20672 .int32Operands = {{1, {0}}}, 20673 // int -> QUANT8_ASYMM map 20674 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 20675 // int -> QUANT16_SYMM map 20676 .quant16SymmOperands = {}, 20677 // int -> FLOAT16 map 20678 .float16Operands = {}, 20679 // int -> BOOL8 map 20680 .bool8Operands = {}, 20681 // int -> QUANT8_SYMM_PER_CHANNEL map 20682 .quant8ChannelOperands = {}, 20683 // int -> QUANT16_ASYMM map 20684 .quant16AsymmOperands = {}, 20685 // int -> QUANT8_SYMM map 20686 .quant8SymmOperands = {}, 20687 } 20688 }, 20689 }, // End of an example 20690 }; 20691 return examples_zero_sized_nhwc_quant8; 20692 }; 20693 20694 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_float16() { 20695 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_float16 = { 20696 // Begin of an example 20697 { 20698 .operands = { 20699 //Input(s) 20700 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20701 // int -> Dimensions map 20702 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20703 // int -> FLOAT32 map 20704 .float32Operands = {}, 20705 // int -> INT32 map 20706 .int32Operands = {}, 20707 // int -> QUANT8_ASYMM map 20708 .quant8AsymmOperands = {}, 20709 // int -> QUANT16_SYMM map 20710 .quant16SymmOperands = {}, 20711 // int -> FLOAT16 map 20712 .float16Operands = {{0, {1.0f}}}, 20713 // int -> BOOL8 map 20714 .bool8Operands = {}, 20715 // int -> QUANT8_SYMM_PER_CHANNEL map 20716 .quant8ChannelOperands = {}, 20717 // int -> QUANT16_ASYMM map 20718 .quant16AsymmOperands = {}, 20719 // int -> QUANT8_SYMM map 20720 .quant8SymmOperands = {}, 20721 }, 20722 //Output(s) 20723 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20724 // int -> Dimensions map 20725 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 20726 // int -> FLOAT32 map 20727 .float32Operands = {}, 20728 // int -> INT32 map 20729 .int32Operands = {{1, {0}}}, 20730 // int -> QUANT8_ASYMM map 20731 .quant8AsymmOperands = {}, 20732 // int -> QUANT16_SYMM map 20733 .quant16SymmOperands = {}, 20734 // int -> FLOAT16 map 20735 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20736 // int -> BOOL8 map 20737 .bool8Operands = {}, 20738 // int -> QUANT8_SYMM_PER_CHANNEL map 20739 .quant8ChannelOperands = {}, 20740 // int -> QUANT16_ASYMM map 20741 .quant16AsymmOperands = {}, 20742 // int -> QUANT8_SYMM map 20743 .quant8SymmOperands = {}, 20744 } 20745 }, 20746 }, // End of an example 20747 }; 20748 return examples_zero_sized_nhwc_float16; 20749 }; 20750 20751 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw() { 20752 static std::vector<MixedTypedExample> examples_zero_sized_nchw = { 20753 // Begin of an example 20754 { 20755 .operands = { 20756 //Input(s) 20757 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20758 // int -> Dimensions map 20759 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20760 // int -> FLOAT32 map 20761 .float32Operands = {{0, {1.0f}}}, 20762 // int -> INT32 map 20763 .int32Operands = {}, 20764 // int -> QUANT8_ASYMM map 20765 .quant8AsymmOperands = {}, 20766 // int -> QUANT16_SYMM map 20767 .quant16SymmOperands = {}, 20768 // int -> FLOAT16 map 20769 .float16Operands = {}, 20770 // int -> BOOL8 map 20771 .bool8Operands = {}, 20772 // int -> QUANT8_SYMM_PER_CHANNEL map 20773 .quant8ChannelOperands = {}, 20774 // int -> QUANT16_ASYMM map 20775 .quant16AsymmOperands = {}, 20776 // int -> QUANT8_SYMM map 20777 .quant8SymmOperands = {}, 20778 }, 20779 //Output(s) 20780 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20781 // int -> Dimensions map 20782 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 20783 // int -> FLOAT32 map 20784 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20785 // int -> INT32 map 20786 .int32Operands = {{1, {0}}}, 20787 // int -> QUANT8_ASYMM map 20788 .quant8AsymmOperands = {}, 20789 // int -> QUANT16_SYMM map 20790 .quant16SymmOperands = {}, 20791 // int -> FLOAT16 map 20792 .float16Operands = {}, 20793 // int -> BOOL8 map 20794 .bool8Operands = {}, 20795 // int -> QUANT8_SYMM_PER_CHANNEL map 20796 .quant8ChannelOperands = {}, 20797 // int -> QUANT16_ASYMM map 20798 .quant16AsymmOperands = {}, 20799 // int -> QUANT8_SYMM map 20800 .quant8SymmOperands = {}, 20801 } 20802 }, 20803 }, // End of an example 20804 }; 20805 return examples_zero_sized_nchw; 20806 }; 20807 20808 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_relaxed() { 20809 static std::vector<MixedTypedExample> examples_zero_sized_nchw_relaxed = { 20810 // Begin of an example 20811 { 20812 .operands = { 20813 //Input(s) 20814 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20815 // int -> Dimensions map 20816 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20817 // int -> FLOAT32 map 20818 .float32Operands = {{0, {1.0f}}}, 20819 // int -> INT32 map 20820 .int32Operands = {}, 20821 // int -> QUANT8_ASYMM map 20822 .quant8AsymmOperands = {}, 20823 // int -> QUANT16_SYMM map 20824 .quant16SymmOperands = {}, 20825 // int -> FLOAT16 map 20826 .float16Operands = {}, 20827 // int -> BOOL8 map 20828 .bool8Operands = {}, 20829 // int -> QUANT8_SYMM_PER_CHANNEL map 20830 .quant8ChannelOperands = {}, 20831 // int -> QUANT16_ASYMM map 20832 .quant16AsymmOperands = {}, 20833 // int -> QUANT8_SYMM map 20834 .quant8SymmOperands = {}, 20835 }, 20836 //Output(s) 20837 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20838 // int -> Dimensions map 20839 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 20840 // int -> FLOAT32 map 20841 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20842 // int -> INT32 map 20843 .int32Operands = {{1, {0}}}, 20844 // int -> QUANT8_ASYMM map 20845 .quant8AsymmOperands = {}, 20846 // int -> QUANT16_SYMM map 20847 .quant16SymmOperands = {}, 20848 // int -> FLOAT16 map 20849 .float16Operands = {}, 20850 // int -> BOOL8 map 20851 .bool8Operands = {}, 20852 // int -> QUANT8_SYMM_PER_CHANNEL map 20853 .quant8ChannelOperands = {}, 20854 // int -> QUANT16_ASYMM map 20855 .quant16AsymmOperands = {}, 20856 // int -> QUANT8_SYMM map 20857 .quant8SymmOperands = {}, 20858 } 20859 }, 20860 }, // End of an example 20861 }; 20862 return examples_zero_sized_nchw_relaxed; 20863 }; 20864 20865 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_quant8() { 20866 static std::vector<MixedTypedExample> examples_zero_sized_nchw_quant8 = { 20867 // Begin of an example 20868 { 20869 .operands = { 20870 //Input(s) 20871 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20872 // int -> Dimensions map 20873 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20874 // int -> FLOAT32 map 20875 .float32Operands = {}, 20876 // int -> INT32 map 20877 .int32Operands = {}, 20878 // int -> QUANT8_ASYMM map 20879 .quant8AsymmOperands = {{0, {138}}}, 20880 // int -> QUANT16_SYMM map 20881 .quant16SymmOperands = {}, 20882 // int -> FLOAT16 map 20883 .float16Operands = {}, 20884 // int -> BOOL8 map 20885 .bool8Operands = {}, 20886 // int -> QUANT8_SYMM_PER_CHANNEL map 20887 .quant8ChannelOperands = {}, 20888 // int -> QUANT16_ASYMM map 20889 .quant16AsymmOperands = {}, 20890 // int -> QUANT8_SYMM map 20891 .quant8SymmOperands = {}, 20892 }, 20893 //Output(s) 20894 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20895 // int -> Dimensions map 20896 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 20897 // int -> FLOAT32 map 20898 .float32Operands = {}, 20899 // int -> INT32 map 20900 .int32Operands = {{1, {0}}}, 20901 // int -> QUANT8_ASYMM map 20902 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 20903 // int -> QUANT16_SYMM map 20904 .quant16SymmOperands = {}, 20905 // int -> FLOAT16 map 20906 .float16Operands = {}, 20907 // int -> BOOL8 map 20908 .bool8Operands = {}, 20909 // int -> QUANT8_SYMM_PER_CHANNEL map 20910 .quant8ChannelOperands = {}, 20911 // int -> QUANT16_ASYMM map 20912 .quant16AsymmOperands = {}, 20913 // int -> QUANT8_SYMM map 20914 .quant8SymmOperands = {}, 20915 } 20916 }, 20917 }, // End of an example 20918 }; 20919 return examples_zero_sized_nchw_quant8; 20920 }; 20921 20922 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_float16() { 20923 static std::vector<MixedTypedExample> examples_zero_sized_nchw_float16 = { 20924 // Begin of an example 20925 { 20926 .operands = { 20927 //Input(s) 20928 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20929 // int -> Dimensions map 20930 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20931 // int -> FLOAT32 map 20932 .float32Operands = {}, 20933 // int -> INT32 map 20934 .int32Operands = {}, 20935 // int -> QUANT8_ASYMM map 20936 .quant8AsymmOperands = {}, 20937 // int -> QUANT16_SYMM map 20938 .quant16SymmOperands = {}, 20939 // int -> FLOAT16 map 20940 .float16Operands = {{0, {1.0f}}}, 20941 // int -> BOOL8 map 20942 .bool8Operands = {}, 20943 // int -> QUANT8_SYMM_PER_CHANNEL map 20944 .quant8ChannelOperands = {}, 20945 // int -> QUANT16_ASYMM map 20946 .quant16AsymmOperands = {}, 20947 // int -> QUANT8_SYMM map 20948 .quant8SymmOperands = {}, 20949 }, 20950 //Output(s) 20951 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20952 // int -> Dimensions map 20953 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 20954 // int -> FLOAT32 map 20955 .float32Operands = {}, 20956 // int -> INT32 map 20957 .int32Operands = {{1, {0}}}, 20958 // int -> QUANT8_ASYMM map 20959 .quant8AsymmOperands = {}, 20960 // int -> QUANT16_SYMM map 20961 .quant16SymmOperands = {}, 20962 // int -> FLOAT16 map 20963 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 20964 // int -> BOOL8 map 20965 .bool8Operands = {}, 20966 // int -> QUANT8_SYMM_PER_CHANNEL map 20967 .quant8ChannelOperands = {}, 20968 // int -> QUANT16_ASYMM map 20969 .quant16AsymmOperands = {}, 20970 // int -> QUANT8_SYMM map 20971 .quant8SymmOperands = {}, 20972 } 20973 }, 20974 }, // End of an example 20975 }; 20976 return examples_zero_sized_nchw_float16; 20977 }; 20978 20979 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc() { 20980 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc = { 20981 // Begin of an example 20982 { 20983 .operands = { 20984 //Input(s) 20985 { // See tools/test_generator/include/TestHarness.h:MixedTyped 20986 // int -> Dimensions map 20987 .operandDimensions = {{0, {1, 1, 1, 1}}}, 20988 // int -> FLOAT32 map 20989 .float32Operands = {{0, {1.0f}}}, 20990 // int -> INT32 map 20991 .int32Operands = {}, 20992 // int -> QUANT8_ASYMM map 20993 .quant8AsymmOperands = {}, 20994 // int -> QUANT16_SYMM map 20995 .quant16SymmOperands = {}, 20996 // int -> FLOAT16 map 20997 .float16Operands = {}, 20998 // int -> BOOL8 map 20999 .bool8Operands = {}, 21000 // int -> QUANT8_SYMM_PER_CHANNEL map 21001 .quant8ChannelOperands = {}, 21002 // int -> QUANT16_ASYMM map 21003 .quant16AsymmOperands = {}, 21004 // int -> QUANT8_SYMM map 21005 .quant8SymmOperands = {}, 21006 }, 21007 //Output(s) 21008 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21009 // int -> Dimensions map 21010 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 21011 // int -> FLOAT32 map 21012 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21013 // int -> INT32 map 21014 .int32Operands = {{1, {0}}}, 21015 // int -> QUANT8_ASYMM map 21016 .quant8AsymmOperands = {}, 21017 // int -> QUANT16_SYMM map 21018 .quant16SymmOperands = {}, 21019 // int -> FLOAT16 map 21020 .float16Operands = {}, 21021 // int -> BOOL8 map 21022 .bool8Operands = {}, 21023 // int -> QUANT8_SYMM_PER_CHANNEL map 21024 .quant8ChannelOperands = {}, 21025 // int -> QUANT16_ASYMM map 21026 .quant16AsymmOperands = {}, 21027 // int -> QUANT8_SYMM map 21028 .quant8SymmOperands = {}, 21029 } 21030 }, 21031 }, // End of an example 21032 }; 21033 return examples_zero_sized_dynamic_output_shape_nhwc; 21034 }; 21035 21036 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_relaxed() { 21037 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_relaxed = { 21038 // Begin of an example 21039 { 21040 .operands = { 21041 //Input(s) 21042 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21043 // int -> Dimensions map 21044 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21045 // int -> FLOAT32 map 21046 .float32Operands = {{0, {1.0f}}}, 21047 // int -> INT32 map 21048 .int32Operands = {}, 21049 // int -> QUANT8_ASYMM map 21050 .quant8AsymmOperands = {}, 21051 // int -> QUANT16_SYMM map 21052 .quant16SymmOperands = {}, 21053 // int -> FLOAT16 map 21054 .float16Operands = {}, 21055 // int -> BOOL8 map 21056 .bool8Operands = {}, 21057 // int -> QUANT8_SYMM_PER_CHANNEL map 21058 .quant8ChannelOperands = {}, 21059 // int -> QUANT16_ASYMM map 21060 .quant16AsymmOperands = {}, 21061 // int -> QUANT8_SYMM map 21062 .quant8SymmOperands = {}, 21063 }, 21064 //Output(s) 21065 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21066 // int -> Dimensions map 21067 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 21068 // int -> FLOAT32 map 21069 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21070 // int -> INT32 map 21071 .int32Operands = {{1, {0}}}, 21072 // int -> QUANT8_ASYMM map 21073 .quant8AsymmOperands = {}, 21074 // int -> QUANT16_SYMM map 21075 .quant16SymmOperands = {}, 21076 // int -> FLOAT16 map 21077 .float16Operands = {}, 21078 // int -> BOOL8 map 21079 .bool8Operands = {}, 21080 // int -> QUANT8_SYMM_PER_CHANNEL map 21081 .quant8ChannelOperands = {}, 21082 // int -> QUANT16_ASYMM map 21083 .quant16AsymmOperands = {}, 21084 // int -> QUANT8_SYMM map 21085 .quant8SymmOperands = {}, 21086 } 21087 }, 21088 }, // End of an example 21089 }; 21090 return examples_zero_sized_dynamic_output_shape_nhwc_relaxed; 21091 }; 21092 21093 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_quant8() { 21094 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_quant8 = { 21095 // Begin of an example 21096 { 21097 .operands = { 21098 //Input(s) 21099 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21100 // int -> Dimensions map 21101 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21102 // int -> FLOAT32 map 21103 .float32Operands = {}, 21104 // int -> INT32 map 21105 .int32Operands = {}, 21106 // int -> QUANT8_ASYMM map 21107 .quant8AsymmOperands = {{0, {138}}}, 21108 // int -> QUANT16_SYMM map 21109 .quant16SymmOperands = {}, 21110 // int -> FLOAT16 map 21111 .float16Operands = {}, 21112 // int -> BOOL8 map 21113 .bool8Operands = {}, 21114 // int -> QUANT8_SYMM_PER_CHANNEL map 21115 .quant8ChannelOperands = {}, 21116 // int -> QUANT16_ASYMM map 21117 .quant16AsymmOperands = {}, 21118 // int -> QUANT8_SYMM map 21119 .quant8SymmOperands = {}, 21120 }, 21121 //Output(s) 21122 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21123 // int -> Dimensions map 21124 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 21125 // int -> FLOAT32 map 21126 .float32Operands = {}, 21127 // int -> INT32 map 21128 .int32Operands = {{1, {0}}}, 21129 // int -> QUANT8_ASYMM map 21130 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 21131 // int -> QUANT16_SYMM map 21132 .quant16SymmOperands = {}, 21133 // int -> FLOAT16 map 21134 .float16Operands = {}, 21135 // int -> BOOL8 map 21136 .bool8Operands = {}, 21137 // int -> QUANT8_SYMM_PER_CHANNEL map 21138 .quant8ChannelOperands = {}, 21139 // int -> QUANT16_ASYMM map 21140 .quant16AsymmOperands = {}, 21141 // int -> QUANT8_SYMM map 21142 .quant8SymmOperands = {}, 21143 } 21144 }, 21145 }, // End of an example 21146 }; 21147 return examples_zero_sized_dynamic_output_shape_nhwc_quant8; 21148 }; 21149 21150 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_float16() { 21151 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_float16 = { 21152 // Begin of an example 21153 { 21154 .operands = { 21155 //Input(s) 21156 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21157 // int -> Dimensions map 21158 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21159 // int -> FLOAT32 map 21160 .float32Operands = {}, 21161 // int -> INT32 map 21162 .int32Operands = {}, 21163 // int -> QUANT8_ASYMM map 21164 .quant8AsymmOperands = {}, 21165 // int -> QUANT16_SYMM map 21166 .quant16SymmOperands = {}, 21167 // int -> FLOAT16 map 21168 .float16Operands = {{0, {1.0f}}}, 21169 // int -> BOOL8 map 21170 .bool8Operands = {}, 21171 // int -> QUANT8_SYMM_PER_CHANNEL map 21172 .quant8ChannelOperands = {}, 21173 // int -> QUANT16_ASYMM map 21174 .quant16AsymmOperands = {}, 21175 // int -> QUANT8_SYMM map 21176 .quant8SymmOperands = {}, 21177 }, 21178 //Output(s) 21179 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21180 // int -> Dimensions map 21181 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 5, 5, 2}}}, 21182 // int -> FLOAT32 map 21183 .float32Operands = {}, 21184 // int -> INT32 map 21185 .int32Operands = {{1, {0}}}, 21186 // int -> QUANT8_ASYMM map 21187 .quant8AsymmOperands = {}, 21188 // int -> QUANT16_SYMM map 21189 .quant16SymmOperands = {}, 21190 // int -> FLOAT16 map 21191 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21192 // int -> BOOL8 map 21193 .bool8Operands = {}, 21194 // int -> QUANT8_SYMM_PER_CHANNEL map 21195 .quant8ChannelOperands = {}, 21196 // int -> QUANT16_ASYMM map 21197 .quant16AsymmOperands = {}, 21198 // int -> QUANT8_SYMM map 21199 .quant8SymmOperands = {}, 21200 } 21201 }, 21202 }, // End of an example 21203 }; 21204 return examples_zero_sized_dynamic_output_shape_nhwc_float16; 21205 }; 21206 21207 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw() { 21208 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw = { 21209 // Begin of an example 21210 { 21211 .operands = { 21212 //Input(s) 21213 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21214 // int -> Dimensions map 21215 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21216 // int -> FLOAT32 map 21217 .float32Operands = {{0, {1.0f}}}, 21218 // int -> INT32 map 21219 .int32Operands = {}, 21220 // int -> QUANT8_ASYMM map 21221 .quant8AsymmOperands = {}, 21222 // int -> QUANT16_SYMM map 21223 .quant16SymmOperands = {}, 21224 // int -> FLOAT16 map 21225 .float16Operands = {}, 21226 // int -> BOOL8 map 21227 .bool8Operands = {}, 21228 // int -> QUANT8_SYMM_PER_CHANNEL map 21229 .quant8ChannelOperands = {}, 21230 // int -> QUANT16_ASYMM map 21231 .quant16AsymmOperands = {}, 21232 // int -> QUANT8_SYMM map 21233 .quant8SymmOperands = {}, 21234 }, 21235 //Output(s) 21236 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21237 // int -> Dimensions map 21238 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 21239 // int -> FLOAT32 map 21240 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21241 // int -> INT32 map 21242 .int32Operands = {{1, {0}}}, 21243 // int -> QUANT8_ASYMM map 21244 .quant8AsymmOperands = {}, 21245 // int -> QUANT16_SYMM map 21246 .quant16SymmOperands = {}, 21247 // int -> FLOAT16 map 21248 .float16Operands = {}, 21249 // int -> BOOL8 map 21250 .bool8Operands = {}, 21251 // int -> QUANT8_SYMM_PER_CHANNEL map 21252 .quant8ChannelOperands = {}, 21253 // int -> QUANT16_ASYMM map 21254 .quant16AsymmOperands = {}, 21255 // int -> QUANT8_SYMM map 21256 .quant8SymmOperands = {}, 21257 } 21258 }, 21259 }, // End of an example 21260 }; 21261 return examples_zero_sized_dynamic_output_shape_nchw; 21262 }; 21263 21264 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_relaxed() { 21265 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_relaxed = { 21266 // Begin of an example 21267 { 21268 .operands = { 21269 //Input(s) 21270 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21271 // int -> Dimensions map 21272 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21273 // int -> FLOAT32 map 21274 .float32Operands = {{0, {1.0f}}}, 21275 // int -> INT32 map 21276 .int32Operands = {}, 21277 // int -> QUANT8_ASYMM map 21278 .quant8AsymmOperands = {}, 21279 // int -> QUANT16_SYMM map 21280 .quant16SymmOperands = {}, 21281 // int -> FLOAT16 map 21282 .float16Operands = {}, 21283 // int -> BOOL8 map 21284 .bool8Operands = {}, 21285 // int -> QUANT8_SYMM_PER_CHANNEL map 21286 .quant8ChannelOperands = {}, 21287 // int -> QUANT16_ASYMM map 21288 .quant16AsymmOperands = {}, 21289 // int -> QUANT8_SYMM map 21290 .quant8SymmOperands = {}, 21291 }, 21292 //Output(s) 21293 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21294 // int -> Dimensions map 21295 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 21296 // int -> FLOAT32 map 21297 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21298 // int -> INT32 map 21299 .int32Operands = {{1, {0}}}, 21300 // int -> QUANT8_ASYMM map 21301 .quant8AsymmOperands = {}, 21302 // int -> QUANT16_SYMM map 21303 .quant16SymmOperands = {}, 21304 // int -> FLOAT16 map 21305 .float16Operands = {}, 21306 // int -> BOOL8 map 21307 .bool8Operands = {}, 21308 // int -> QUANT8_SYMM_PER_CHANNEL map 21309 .quant8ChannelOperands = {}, 21310 // int -> QUANT16_ASYMM map 21311 .quant16AsymmOperands = {}, 21312 // int -> QUANT8_SYMM map 21313 .quant8SymmOperands = {}, 21314 } 21315 }, 21316 }, // End of an example 21317 }; 21318 return examples_zero_sized_dynamic_output_shape_nchw_relaxed; 21319 }; 21320 21321 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_quant8() { 21322 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_quant8 = { 21323 // Begin of an example 21324 { 21325 .operands = { 21326 //Input(s) 21327 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21328 // int -> Dimensions map 21329 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21330 // int -> FLOAT32 map 21331 .float32Operands = {}, 21332 // int -> INT32 map 21333 .int32Operands = {}, 21334 // int -> QUANT8_ASYMM map 21335 .quant8AsymmOperands = {{0, {138}}}, 21336 // int -> QUANT16_SYMM map 21337 .quant16SymmOperands = {}, 21338 // int -> FLOAT16 map 21339 .float16Operands = {}, 21340 // int -> BOOL8 map 21341 .bool8Operands = {}, 21342 // int -> QUANT8_SYMM_PER_CHANNEL map 21343 .quant8ChannelOperands = {}, 21344 // int -> QUANT16_ASYMM map 21345 .quant16AsymmOperands = {}, 21346 // int -> QUANT8_SYMM map 21347 .quant8SymmOperands = {}, 21348 }, 21349 //Output(s) 21350 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21351 // int -> Dimensions map 21352 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 21353 // int -> FLOAT32 map 21354 .float32Operands = {}, 21355 // int -> INT32 map 21356 .int32Operands = {{1, {0}}}, 21357 // int -> QUANT8_ASYMM map 21358 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 21359 // int -> QUANT16_SYMM map 21360 .quant16SymmOperands = {}, 21361 // int -> FLOAT16 map 21362 .float16Operands = {}, 21363 // int -> BOOL8 map 21364 .bool8Operands = {}, 21365 // int -> QUANT8_SYMM_PER_CHANNEL map 21366 .quant8ChannelOperands = {}, 21367 // int -> QUANT16_ASYMM map 21368 .quant16AsymmOperands = {}, 21369 // int -> QUANT8_SYMM map 21370 .quant8SymmOperands = {}, 21371 } 21372 }, 21373 }, // End of an example 21374 }; 21375 return examples_zero_sized_dynamic_output_shape_nchw_quant8; 21376 }; 21377 21378 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_float16() { 21379 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_float16 = { 21380 // Begin of an example 21381 { 21382 .operands = { 21383 //Input(s) 21384 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21385 // int -> Dimensions map 21386 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21387 // int -> FLOAT32 map 21388 .float32Operands = {}, 21389 // int -> INT32 map 21390 .int32Operands = {}, 21391 // int -> QUANT8_ASYMM map 21392 .quant8AsymmOperands = {}, 21393 // int -> QUANT16_SYMM map 21394 .quant16SymmOperands = {}, 21395 // int -> FLOAT16 map 21396 .float16Operands = {{0, {1.0f}}}, 21397 // int -> BOOL8 map 21398 .bool8Operands = {}, 21399 // int -> QUANT8_SYMM_PER_CHANNEL map 21400 .quant8ChannelOperands = {}, 21401 // int -> QUANT16_ASYMM map 21402 .quant16AsymmOperands = {}, 21403 // int -> QUANT8_SYMM map 21404 .quant8SymmOperands = {}, 21405 }, 21406 //Output(s) 21407 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21408 // int -> Dimensions map 21409 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 5, 5}}}, 21410 // int -> FLOAT32 map 21411 .float32Operands = {}, 21412 // int -> INT32 map 21413 .int32Operands = {{1, {0}}}, 21414 // int -> QUANT8_ASYMM map 21415 .quant8AsymmOperands = {}, 21416 // int -> QUANT16_SYMM map 21417 .quant16SymmOperands = {}, 21418 // int -> FLOAT16 map 21419 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21420 // int -> BOOL8 map 21421 .bool8Operands = {}, 21422 // int -> QUANT8_SYMM_PER_CHANNEL map 21423 .quant8ChannelOperands = {}, 21424 // int -> QUANT16_ASYMM map 21425 .quant16AsymmOperands = {}, 21426 // int -> QUANT8_SYMM map 21427 .quant8SymmOperands = {}, 21428 } 21429 }, 21430 }, // End of an example 21431 }; 21432 return examples_zero_sized_dynamic_output_shape_nchw_float16; 21433 }; 21434 21435 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_2() { 21436 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_2 = { 21437 // Begin of an example 21438 { 21439 .operands = { 21440 //Input(s) 21441 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21442 // int -> Dimensions map 21443 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21444 // int -> FLOAT32 map 21445 .float32Operands = {{0, {1.0f}}}, 21446 // int -> INT32 map 21447 .int32Operands = {}, 21448 // int -> QUANT8_ASYMM map 21449 .quant8AsymmOperands = {}, 21450 // int -> QUANT16_SYMM map 21451 .quant16SymmOperands = {}, 21452 // int -> FLOAT16 map 21453 .float16Operands = {}, 21454 // int -> BOOL8 map 21455 .bool8Operands = {}, 21456 // int -> QUANT8_SYMM_PER_CHANNEL map 21457 .quant8ChannelOperands = {}, 21458 // int -> QUANT16_ASYMM map 21459 .quant16AsymmOperands = {}, 21460 // int -> QUANT8_SYMM map 21461 .quant8SymmOperands = {}, 21462 }, 21463 //Output(s) 21464 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21465 // int -> Dimensions map 21466 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21467 // int -> FLOAT32 map 21468 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21469 // int -> INT32 map 21470 .int32Operands = {{1, {0}}}, 21471 // int -> QUANT8_ASYMM map 21472 .quant8AsymmOperands = {}, 21473 // int -> QUANT16_SYMM map 21474 .quant16SymmOperands = {}, 21475 // int -> FLOAT16 map 21476 .float16Operands = {}, 21477 // int -> BOOL8 map 21478 .bool8Operands = {}, 21479 // int -> QUANT8_SYMM_PER_CHANNEL map 21480 .quant8ChannelOperands = {}, 21481 // int -> QUANT16_ASYMM map 21482 .quant16AsymmOperands = {}, 21483 // int -> QUANT8_SYMM map 21484 .quant8SymmOperands = {}, 21485 } 21486 }, 21487 }, // End of an example 21488 }; 21489 return examples_zero_sized_nhwc_2; 21490 }; 21491 21492 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_relaxed_2() { 21493 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_relaxed_2 = { 21494 // Begin of an example 21495 { 21496 .operands = { 21497 //Input(s) 21498 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21499 // int -> Dimensions map 21500 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21501 // int -> FLOAT32 map 21502 .float32Operands = {{0, {1.0f}}}, 21503 // int -> INT32 map 21504 .int32Operands = {}, 21505 // int -> QUANT8_ASYMM map 21506 .quant8AsymmOperands = {}, 21507 // int -> QUANT16_SYMM map 21508 .quant16SymmOperands = {}, 21509 // int -> FLOAT16 map 21510 .float16Operands = {}, 21511 // int -> BOOL8 map 21512 .bool8Operands = {}, 21513 // int -> QUANT8_SYMM_PER_CHANNEL map 21514 .quant8ChannelOperands = {}, 21515 // int -> QUANT16_ASYMM map 21516 .quant16AsymmOperands = {}, 21517 // int -> QUANT8_SYMM map 21518 .quant8SymmOperands = {}, 21519 }, 21520 //Output(s) 21521 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21522 // int -> Dimensions map 21523 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21524 // int -> FLOAT32 map 21525 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21526 // int -> INT32 map 21527 .int32Operands = {{1, {0}}}, 21528 // int -> QUANT8_ASYMM map 21529 .quant8AsymmOperands = {}, 21530 // int -> QUANT16_SYMM map 21531 .quant16SymmOperands = {}, 21532 // int -> FLOAT16 map 21533 .float16Operands = {}, 21534 // int -> BOOL8 map 21535 .bool8Operands = {}, 21536 // int -> QUANT8_SYMM_PER_CHANNEL map 21537 .quant8ChannelOperands = {}, 21538 // int -> QUANT16_ASYMM map 21539 .quant16AsymmOperands = {}, 21540 // int -> QUANT8_SYMM map 21541 .quant8SymmOperands = {}, 21542 } 21543 }, 21544 }, // End of an example 21545 }; 21546 return examples_zero_sized_nhwc_relaxed_2; 21547 }; 21548 21549 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_quant8_2() { 21550 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_quant8_2 = { 21551 // Begin of an example 21552 { 21553 .operands = { 21554 //Input(s) 21555 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21556 // int -> Dimensions map 21557 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21558 // int -> FLOAT32 map 21559 .float32Operands = {}, 21560 // int -> INT32 map 21561 .int32Operands = {}, 21562 // int -> QUANT8_ASYMM map 21563 .quant8AsymmOperands = {{0, {138}}}, 21564 // int -> QUANT16_SYMM map 21565 .quant16SymmOperands = {}, 21566 // int -> FLOAT16 map 21567 .float16Operands = {}, 21568 // int -> BOOL8 map 21569 .bool8Operands = {}, 21570 // int -> QUANT8_SYMM_PER_CHANNEL map 21571 .quant8ChannelOperands = {}, 21572 // int -> QUANT16_ASYMM map 21573 .quant16AsymmOperands = {}, 21574 // int -> QUANT8_SYMM map 21575 .quant8SymmOperands = {}, 21576 }, 21577 //Output(s) 21578 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21579 // int -> Dimensions map 21580 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21581 // int -> FLOAT32 map 21582 .float32Operands = {}, 21583 // int -> INT32 map 21584 .int32Operands = {{1, {0}}}, 21585 // int -> QUANT8_ASYMM map 21586 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 21587 // int -> QUANT16_SYMM map 21588 .quant16SymmOperands = {}, 21589 // int -> FLOAT16 map 21590 .float16Operands = {}, 21591 // int -> BOOL8 map 21592 .bool8Operands = {}, 21593 // int -> QUANT8_SYMM_PER_CHANNEL map 21594 .quant8ChannelOperands = {}, 21595 // int -> QUANT16_ASYMM map 21596 .quant16AsymmOperands = {}, 21597 // int -> QUANT8_SYMM map 21598 .quant8SymmOperands = {}, 21599 } 21600 }, 21601 }, // End of an example 21602 }; 21603 return examples_zero_sized_nhwc_quant8_2; 21604 }; 21605 21606 std::vector<MixedTypedExample>& get_examples_zero_sized_nhwc_float16_2() { 21607 static std::vector<MixedTypedExample> examples_zero_sized_nhwc_float16_2 = { 21608 // Begin of an example 21609 { 21610 .operands = { 21611 //Input(s) 21612 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21613 // int -> Dimensions map 21614 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21615 // int -> FLOAT32 map 21616 .float32Operands = {}, 21617 // int -> INT32 map 21618 .int32Operands = {}, 21619 // int -> QUANT8_ASYMM map 21620 .quant8AsymmOperands = {}, 21621 // int -> QUANT16_SYMM map 21622 .quant16SymmOperands = {}, 21623 // int -> FLOAT16 map 21624 .float16Operands = {{0, {1.0f}}}, 21625 // int -> BOOL8 map 21626 .bool8Operands = {}, 21627 // int -> QUANT8_SYMM_PER_CHANNEL map 21628 .quant8ChannelOperands = {}, 21629 // int -> QUANT16_ASYMM map 21630 .quant16AsymmOperands = {}, 21631 // int -> QUANT8_SYMM map 21632 .quant8SymmOperands = {}, 21633 }, 21634 //Output(s) 21635 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21636 // int -> Dimensions map 21637 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21638 // int -> FLOAT32 map 21639 .float32Operands = {}, 21640 // int -> INT32 map 21641 .int32Operands = {{1, {0}}}, 21642 // int -> QUANT8_ASYMM map 21643 .quant8AsymmOperands = {}, 21644 // int -> QUANT16_SYMM map 21645 .quant16SymmOperands = {}, 21646 // int -> FLOAT16 map 21647 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21648 // int -> BOOL8 map 21649 .bool8Operands = {}, 21650 // int -> QUANT8_SYMM_PER_CHANNEL map 21651 .quant8ChannelOperands = {}, 21652 // int -> QUANT16_ASYMM map 21653 .quant16AsymmOperands = {}, 21654 // int -> QUANT8_SYMM map 21655 .quant8SymmOperands = {}, 21656 } 21657 }, 21658 }, // End of an example 21659 }; 21660 return examples_zero_sized_nhwc_float16_2; 21661 }; 21662 21663 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_2() { 21664 static std::vector<MixedTypedExample> examples_zero_sized_nchw_2 = { 21665 // Begin of an example 21666 { 21667 .operands = { 21668 //Input(s) 21669 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21670 // int -> Dimensions map 21671 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21672 // int -> FLOAT32 map 21673 .float32Operands = {{0, {1.0f}}}, 21674 // int -> INT32 map 21675 .int32Operands = {}, 21676 // int -> QUANT8_ASYMM map 21677 .quant8AsymmOperands = {}, 21678 // int -> QUANT16_SYMM map 21679 .quant16SymmOperands = {}, 21680 // int -> FLOAT16 map 21681 .float16Operands = {}, 21682 // int -> BOOL8 map 21683 .bool8Operands = {}, 21684 // int -> QUANT8_SYMM_PER_CHANNEL map 21685 .quant8ChannelOperands = {}, 21686 // int -> QUANT16_ASYMM map 21687 .quant16AsymmOperands = {}, 21688 // int -> QUANT8_SYMM map 21689 .quant8SymmOperands = {}, 21690 }, 21691 //Output(s) 21692 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21693 // int -> Dimensions map 21694 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 21695 // int -> FLOAT32 map 21696 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21697 // int -> INT32 map 21698 .int32Operands = {{1, {0}}}, 21699 // int -> QUANT8_ASYMM map 21700 .quant8AsymmOperands = {}, 21701 // int -> QUANT16_SYMM map 21702 .quant16SymmOperands = {}, 21703 // int -> FLOAT16 map 21704 .float16Operands = {}, 21705 // int -> BOOL8 map 21706 .bool8Operands = {}, 21707 // int -> QUANT8_SYMM_PER_CHANNEL map 21708 .quant8ChannelOperands = {}, 21709 // int -> QUANT16_ASYMM map 21710 .quant16AsymmOperands = {}, 21711 // int -> QUANT8_SYMM map 21712 .quant8SymmOperands = {}, 21713 } 21714 }, 21715 }, // End of an example 21716 }; 21717 return examples_zero_sized_nchw_2; 21718 }; 21719 21720 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_relaxed_2() { 21721 static std::vector<MixedTypedExample> examples_zero_sized_nchw_relaxed_2 = { 21722 // Begin of an example 21723 { 21724 .operands = { 21725 //Input(s) 21726 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21727 // int -> Dimensions map 21728 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21729 // int -> FLOAT32 map 21730 .float32Operands = {{0, {1.0f}}}, 21731 // int -> INT32 map 21732 .int32Operands = {}, 21733 // int -> QUANT8_ASYMM map 21734 .quant8AsymmOperands = {}, 21735 // int -> QUANT16_SYMM map 21736 .quant16SymmOperands = {}, 21737 // int -> FLOAT16 map 21738 .float16Operands = {}, 21739 // int -> BOOL8 map 21740 .bool8Operands = {}, 21741 // int -> QUANT8_SYMM_PER_CHANNEL map 21742 .quant8ChannelOperands = {}, 21743 // int -> QUANT16_ASYMM map 21744 .quant16AsymmOperands = {}, 21745 // int -> QUANT8_SYMM map 21746 .quant8SymmOperands = {}, 21747 }, 21748 //Output(s) 21749 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21750 // int -> Dimensions map 21751 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 21752 // int -> FLOAT32 map 21753 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21754 // int -> INT32 map 21755 .int32Operands = {{1, {0}}}, 21756 // int -> QUANT8_ASYMM map 21757 .quant8AsymmOperands = {}, 21758 // int -> QUANT16_SYMM map 21759 .quant16SymmOperands = {}, 21760 // int -> FLOAT16 map 21761 .float16Operands = {}, 21762 // int -> BOOL8 map 21763 .bool8Operands = {}, 21764 // int -> QUANT8_SYMM_PER_CHANNEL map 21765 .quant8ChannelOperands = {}, 21766 // int -> QUANT16_ASYMM map 21767 .quant16AsymmOperands = {}, 21768 // int -> QUANT8_SYMM map 21769 .quant8SymmOperands = {}, 21770 } 21771 }, 21772 }, // End of an example 21773 }; 21774 return examples_zero_sized_nchw_relaxed_2; 21775 }; 21776 21777 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_quant8_2() { 21778 static std::vector<MixedTypedExample> examples_zero_sized_nchw_quant8_2 = { 21779 // Begin of an example 21780 { 21781 .operands = { 21782 //Input(s) 21783 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21784 // int -> Dimensions map 21785 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21786 // int -> FLOAT32 map 21787 .float32Operands = {}, 21788 // int -> INT32 map 21789 .int32Operands = {}, 21790 // int -> QUANT8_ASYMM map 21791 .quant8AsymmOperands = {{0, {138}}}, 21792 // int -> QUANT16_SYMM map 21793 .quant16SymmOperands = {}, 21794 // int -> FLOAT16 map 21795 .float16Operands = {}, 21796 // int -> BOOL8 map 21797 .bool8Operands = {}, 21798 // int -> QUANT8_SYMM_PER_CHANNEL map 21799 .quant8ChannelOperands = {}, 21800 // int -> QUANT16_ASYMM map 21801 .quant16AsymmOperands = {}, 21802 // int -> QUANT8_SYMM map 21803 .quant8SymmOperands = {}, 21804 }, 21805 //Output(s) 21806 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21807 // int -> Dimensions map 21808 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 21809 // int -> FLOAT32 map 21810 .float32Operands = {}, 21811 // int -> INT32 map 21812 .int32Operands = {{1, {0}}}, 21813 // int -> QUANT8_ASYMM map 21814 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 21815 // int -> QUANT16_SYMM map 21816 .quant16SymmOperands = {}, 21817 // int -> FLOAT16 map 21818 .float16Operands = {}, 21819 // int -> BOOL8 map 21820 .bool8Operands = {}, 21821 // int -> QUANT8_SYMM_PER_CHANNEL map 21822 .quant8ChannelOperands = {}, 21823 // int -> QUANT16_ASYMM map 21824 .quant16AsymmOperands = {}, 21825 // int -> QUANT8_SYMM map 21826 .quant8SymmOperands = {}, 21827 } 21828 }, 21829 }, // End of an example 21830 }; 21831 return examples_zero_sized_nchw_quant8_2; 21832 }; 21833 21834 std::vector<MixedTypedExample>& get_examples_zero_sized_nchw_float16_2() { 21835 static std::vector<MixedTypedExample> examples_zero_sized_nchw_float16_2 = { 21836 // Begin of an example 21837 { 21838 .operands = { 21839 //Input(s) 21840 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21841 // int -> Dimensions map 21842 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21843 // int -> FLOAT32 map 21844 .float32Operands = {}, 21845 // int -> INT32 map 21846 .int32Operands = {}, 21847 // int -> QUANT8_ASYMM map 21848 .quant8AsymmOperands = {}, 21849 // int -> QUANT16_SYMM map 21850 .quant16SymmOperands = {}, 21851 // int -> FLOAT16 map 21852 .float16Operands = {{0, {1.0f}}}, 21853 // int -> BOOL8 map 21854 .bool8Operands = {}, 21855 // int -> QUANT8_SYMM_PER_CHANNEL map 21856 .quant8ChannelOperands = {}, 21857 // int -> QUANT16_ASYMM map 21858 .quant16AsymmOperands = {}, 21859 // int -> QUANT8_SYMM map 21860 .quant8SymmOperands = {}, 21861 }, 21862 //Output(s) 21863 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21864 // int -> Dimensions map 21865 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 21866 // int -> FLOAT32 map 21867 .float32Operands = {}, 21868 // int -> INT32 map 21869 .int32Operands = {{1, {0}}}, 21870 // int -> QUANT8_ASYMM map 21871 .quant8AsymmOperands = {}, 21872 // int -> QUANT16_SYMM map 21873 .quant16SymmOperands = {}, 21874 // int -> FLOAT16 map 21875 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21876 // int -> BOOL8 map 21877 .bool8Operands = {}, 21878 // int -> QUANT8_SYMM_PER_CHANNEL map 21879 .quant8ChannelOperands = {}, 21880 // int -> QUANT16_ASYMM map 21881 .quant16AsymmOperands = {}, 21882 // int -> QUANT8_SYMM map 21883 .quant8SymmOperands = {}, 21884 } 21885 }, 21886 }, // End of an example 21887 }; 21888 return examples_zero_sized_nchw_float16_2; 21889 }; 21890 21891 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_2() { 21892 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_2 = { 21893 // Begin of an example 21894 { 21895 .operands = { 21896 //Input(s) 21897 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21898 // int -> Dimensions map 21899 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21900 // int -> FLOAT32 map 21901 .float32Operands = {{0, {1.0f}}}, 21902 // int -> INT32 map 21903 .int32Operands = {}, 21904 // int -> QUANT8_ASYMM map 21905 .quant8AsymmOperands = {}, 21906 // int -> QUANT16_SYMM map 21907 .quant16SymmOperands = {}, 21908 // int -> FLOAT16 map 21909 .float16Operands = {}, 21910 // int -> BOOL8 map 21911 .bool8Operands = {}, 21912 // int -> QUANT8_SYMM_PER_CHANNEL map 21913 .quant8ChannelOperands = {}, 21914 // int -> QUANT16_ASYMM map 21915 .quant16AsymmOperands = {}, 21916 // int -> QUANT8_SYMM map 21917 .quant8SymmOperands = {}, 21918 }, 21919 //Output(s) 21920 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21921 // int -> Dimensions map 21922 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21923 // int -> FLOAT32 map 21924 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21925 // int -> INT32 map 21926 .int32Operands = {{1, {0}}}, 21927 // int -> QUANT8_ASYMM map 21928 .quant8AsymmOperands = {}, 21929 // int -> QUANT16_SYMM map 21930 .quant16SymmOperands = {}, 21931 // int -> FLOAT16 map 21932 .float16Operands = {}, 21933 // int -> BOOL8 map 21934 .bool8Operands = {}, 21935 // int -> QUANT8_SYMM_PER_CHANNEL map 21936 .quant8ChannelOperands = {}, 21937 // int -> QUANT16_ASYMM map 21938 .quant16AsymmOperands = {}, 21939 // int -> QUANT8_SYMM map 21940 .quant8SymmOperands = {}, 21941 } 21942 }, 21943 }, // End of an example 21944 }; 21945 return examples_zero_sized_dynamic_output_shape_nhwc_2; 21946 }; 21947 21948 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_relaxed_2() { 21949 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_relaxed_2 = { 21950 // Begin of an example 21951 { 21952 .operands = { 21953 //Input(s) 21954 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21955 // int -> Dimensions map 21956 .operandDimensions = {{0, {1, 1, 1, 1}}}, 21957 // int -> FLOAT32 map 21958 .float32Operands = {{0, {1.0f}}}, 21959 // int -> INT32 map 21960 .int32Operands = {}, 21961 // int -> QUANT8_ASYMM map 21962 .quant8AsymmOperands = {}, 21963 // int -> QUANT16_SYMM map 21964 .quant16SymmOperands = {}, 21965 // int -> FLOAT16 map 21966 .float16Operands = {}, 21967 // int -> BOOL8 map 21968 .bool8Operands = {}, 21969 // int -> QUANT8_SYMM_PER_CHANNEL map 21970 .quant8ChannelOperands = {}, 21971 // int -> QUANT16_ASYMM map 21972 .quant16AsymmOperands = {}, 21973 // int -> QUANT8_SYMM map 21974 .quant8SymmOperands = {}, 21975 }, 21976 //Output(s) 21977 { // See tools/test_generator/include/TestHarness.h:MixedTyped 21978 // int -> Dimensions map 21979 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 21980 // int -> FLOAT32 map 21981 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 21982 // int -> INT32 map 21983 .int32Operands = {{1, {0}}}, 21984 // int -> QUANT8_ASYMM map 21985 .quant8AsymmOperands = {}, 21986 // int -> QUANT16_SYMM map 21987 .quant16SymmOperands = {}, 21988 // int -> FLOAT16 map 21989 .float16Operands = {}, 21990 // int -> BOOL8 map 21991 .bool8Operands = {}, 21992 // int -> QUANT8_SYMM_PER_CHANNEL map 21993 .quant8ChannelOperands = {}, 21994 // int -> QUANT16_ASYMM map 21995 .quant16AsymmOperands = {}, 21996 // int -> QUANT8_SYMM map 21997 .quant8SymmOperands = {}, 21998 } 21999 }, 22000 }, // End of an example 22001 }; 22002 return examples_zero_sized_dynamic_output_shape_nhwc_relaxed_2; 22003 }; 22004 22005 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_quant8_2() { 22006 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_quant8_2 = { 22007 // Begin of an example 22008 { 22009 .operands = { 22010 //Input(s) 22011 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22012 // int -> Dimensions map 22013 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22014 // int -> FLOAT32 map 22015 .float32Operands = {}, 22016 // int -> INT32 map 22017 .int32Operands = {}, 22018 // int -> QUANT8_ASYMM map 22019 .quant8AsymmOperands = {{0, {138}}}, 22020 // int -> QUANT16_SYMM map 22021 .quant16SymmOperands = {}, 22022 // int -> FLOAT16 map 22023 .float16Operands = {}, 22024 // int -> BOOL8 map 22025 .bool8Operands = {}, 22026 // int -> QUANT8_SYMM_PER_CHANNEL map 22027 .quant8ChannelOperands = {}, 22028 // int -> QUANT16_ASYMM map 22029 .quant16AsymmOperands = {}, 22030 // int -> QUANT8_SYMM map 22031 .quant8SymmOperands = {}, 22032 }, 22033 //Output(s) 22034 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22035 // int -> Dimensions map 22036 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 22037 // int -> FLOAT32 map 22038 .float32Operands = {}, 22039 // int -> INT32 map 22040 .int32Operands = {{1, {0}}}, 22041 // int -> QUANT8_ASYMM map 22042 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 22043 // int -> QUANT16_SYMM map 22044 .quant16SymmOperands = {}, 22045 // int -> FLOAT16 map 22046 .float16Operands = {}, 22047 // int -> BOOL8 map 22048 .bool8Operands = {}, 22049 // int -> QUANT8_SYMM_PER_CHANNEL map 22050 .quant8ChannelOperands = {}, 22051 // int -> QUANT16_ASYMM map 22052 .quant16AsymmOperands = {}, 22053 // int -> QUANT8_SYMM map 22054 .quant8SymmOperands = {}, 22055 } 22056 }, 22057 }, // End of an example 22058 }; 22059 return examples_zero_sized_dynamic_output_shape_nhwc_quant8_2; 22060 }; 22061 22062 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nhwc_float16_2() { 22063 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nhwc_float16_2 = { 22064 // Begin of an example 22065 { 22066 .operands = { 22067 //Input(s) 22068 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22069 // int -> Dimensions map 22070 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22071 // int -> FLOAT32 map 22072 .float32Operands = {}, 22073 // int -> INT32 map 22074 .int32Operands = {}, 22075 // int -> QUANT8_ASYMM map 22076 .quant8AsymmOperands = {}, 22077 // int -> QUANT16_SYMM map 22078 .quant16SymmOperands = {}, 22079 // int -> FLOAT16 map 22080 .float16Operands = {{0, {1.0f}}}, 22081 // int -> BOOL8 map 22082 .bool8Operands = {}, 22083 // int -> QUANT8_SYMM_PER_CHANNEL map 22084 .quant8ChannelOperands = {}, 22085 // int -> QUANT16_ASYMM map 22086 .quant16AsymmOperands = {}, 22087 // int -> QUANT8_SYMM map 22088 .quant8SymmOperands = {}, 22089 }, 22090 //Output(s) 22091 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22092 // int -> Dimensions map 22093 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 3, 3, 1}}}, 22094 // int -> FLOAT32 map 22095 .float32Operands = {}, 22096 // int -> INT32 map 22097 .int32Operands = {{1, {0}}}, 22098 // int -> QUANT8_ASYMM map 22099 .quant8AsymmOperands = {}, 22100 // int -> QUANT16_SYMM map 22101 .quant16SymmOperands = {}, 22102 // int -> FLOAT16 map 22103 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 22104 // int -> BOOL8 map 22105 .bool8Operands = {}, 22106 // int -> QUANT8_SYMM_PER_CHANNEL map 22107 .quant8ChannelOperands = {}, 22108 // int -> QUANT16_ASYMM map 22109 .quant16AsymmOperands = {}, 22110 // int -> QUANT8_SYMM map 22111 .quant8SymmOperands = {}, 22112 } 22113 }, 22114 }, // End of an example 22115 }; 22116 return examples_zero_sized_dynamic_output_shape_nhwc_float16_2; 22117 }; 22118 22119 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_2() { 22120 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_2 = { 22121 // Begin of an example 22122 { 22123 .operands = { 22124 //Input(s) 22125 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22126 // int -> Dimensions map 22127 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22128 // int -> FLOAT32 map 22129 .float32Operands = {{0, {1.0f}}}, 22130 // int -> INT32 map 22131 .int32Operands = {}, 22132 // int -> QUANT8_ASYMM map 22133 .quant8AsymmOperands = {}, 22134 // int -> QUANT16_SYMM map 22135 .quant16SymmOperands = {}, 22136 // int -> FLOAT16 map 22137 .float16Operands = {}, 22138 // int -> BOOL8 map 22139 .bool8Operands = {}, 22140 // int -> QUANT8_SYMM_PER_CHANNEL map 22141 .quant8ChannelOperands = {}, 22142 // int -> QUANT16_ASYMM map 22143 .quant16AsymmOperands = {}, 22144 // int -> QUANT8_SYMM map 22145 .quant8SymmOperands = {}, 22146 }, 22147 //Output(s) 22148 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22149 // int -> Dimensions map 22150 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 22151 // int -> FLOAT32 map 22152 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 22153 // int -> INT32 map 22154 .int32Operands = {{1, {0}}}, 22155 // int -> QUANT8_ASYMM map 22156 .quant8AsymmOperands = {}, 22157 // int -> QUANT16_SYMM map 22158 .quant16SymmOperands = {}, 22159 // int -> FLOAT16 map 22160 .float16Operands = {}, 22161 // int -> BOOL8 map 22162 .bool8Operands = {}, 22163 // int -> QUANT8_SYMM_PER_CHANNEL map 22164 .quant8ChannelOperands = {}, 22165 // int -> QUANT16_ASYMM map 22166 .quant16AsymmOperands = {}, 22167 // int -> QUANT8_SYMM map 22168 .quant8SymmOperands = {}, 22169 } 22170 }, 22171 }, // End of an example 22172 }; 22173 return examples_zero_sized_dynamic_output_shape_nchw_2; 22174 }; 22175 22176 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_relaxed_2() { 22177 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_relaxed_2 = { 22178 // Begin of an example 22179 { 22180 .operands = { 22181 //Input(s) 22182 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22183 // int -> Dimensions map 22184 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22185 // int -> FLOAT32 map 22186 .float32Operands = {{0, {1.0f}}}, 22187 // int -> INT32 map 22188 .int32Operands = {}, 22189 // int -> QUANT8_ASYMM map 22190 .quant8AsymmOperands = {}, 22191 // int -> QUANT16_SYMM map 22192 .quant16SymmOperands = {}, 22193 // int -> FLOAT16 map 22194 .float16Operands = {}, 22195 // int -> BOOL8 map 22196 .bool8Operands = {}, 22197 // int -> QUANT8_SYMM_PER_CHANNEL map 22198 .quant8ChannelOperands = {}, 22199 // int -> QUANT16_ASYMM map 22200 .quant16AsymmOperands = {}, 22201 // int -> QUANT8_SYMM map 22202 .quant8SymmOperands = {}, 22203 }, 22204 //Output(s) 22205 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22206 // int -> Dimensions map 22207 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 22208 // int -> FLOAT32 map 22209 .float32Operands = {{0, {0.0f}}, {2, {0.0f}}}, 22210 // int -> INT32 map 22211 .int32Operands = {{1, {0}}}, 22212 // int -> QUANT8_ASYMM map 22213 .quant8AsymmOperands = {}, 22214 // int -> QUANT16_SYMM map 22215 .quant16SymmOperands = {}, 22216 // int -> FLOAT16 map 22217 .float16Operands = {}, 22218 // int -> BOOL8 map 22219 .bool8Operands = {}, 22220 // int -> QUANT8_SYMM_PER_CHANNEL map 22221 .quant8ChannelOperands = {}, 22222 // int -> QUANT16_ASYMM map 22223 .quant16AsymmOperands = {}, 22224 // int -> QUANT8_SYMM map 22225 .quant8SymmOperands = {}, 22226 } 22227 }, 22228 }, // End of an example 22229 }; 22230 return examples_zero_sized_dynamic_output_shape_nchw_relaxed_2; 22231 }; 22232 22233 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_quant8_2() { 22234 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_quant8_2 = { 22235 // Begin of an example 22236 { 22237 .operands = { 22238 //Input(s) 22239 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22240 // int -> Dimensions map 22241 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22242 // int -> FLOAT32 map 22243 .float32Operands = {}, 22244 // int -> INT32 map 22245 .int32Operands = {}, 22246 // int -> QUANT8_ASYMM map 22247 .quant8AsymmOperands = {{0, {138}}}, 22248 // int -> QUANT16_SYMM map 22249 .quant16SymmOperands = {}, 22250 // int -> FLOAT16 map 22251 .float16Operands = {}, 22252 // int -> BOOL8 map 22253 .bool8Operands = {}, 22254 // int -> QUANT8_SYMM_PER_CHANNEL map 22255 .quant8ChannelOperands = {}, 22256 // int -> QUANT16_ASYMM map 22257 .quant16AsymmOperands = {}, 22258 // int -> QUANT8_SYMM map 22259 .quant8SymmOperands = {}, 22260 }, 22261 //Output(s) 22262 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22263 // int -> Dimensions map 22264 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 22265 // int -> FLOAT32 map 22266 .float32Operands = {}, 22267 // int -> INT32 map 22268 .int32Operands = {{1, {0}}}, 22269 // int -> QUANT8_ASYMM map 22270 .quant8AsymmOperands = {{0, {0}}, {2, {0}}}, 22271 // int -> QUANT16_SYMM map 22272 .quant16SymmOperands = {}, 22273 // int -> FLOAT16 map 22274 .float16Operands = {}, 22275 // int -> BOOL8 map 22276 .bool8Operands = {}, 22277 // int -> QUANT8_SYMM_PER_CHANNEL map 22278 .quant8ChannelOperands = {}, 22279 // int -> QUANT16_ASYMM map 22280 .quant16AsymmOperands = {}, 22281 // int -> QUANT8_SYMM map 22282 .quant8SymmOperands = {}, 22283 } 22284 }, 22285 }, // End of an example 22286 }; 22287 return examples_zero_sized_dynamic_output_shape_nchw_quant8_2; 22288 }; 22289 22290 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_nchw_float16_2() { 22291 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_nchw_float16_2 = { 22292 // Begin of an example 22293 { 22294 .operands = { 22295 //Input(s) 22296 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22297 // int -> Dimensions map 22298 .operandDimensions = {{0, {1, 1, 1, 1}}}, 22299 // int -> FLOAT32 map 22300 .float32Operands = {}, 22301 // int -> INT32 map 22302 .int32Operands = {}, 22303 // int -> QUANT8_ASYMM map 22304 .quant8AsymmOperands = {}, 22305 // int -> QUANT16_SYMM map 22306 .quant16SymmOperands = {}, 22307 // int -> FLOAT16 map 22308 .float16Operands = {{0, {1.0f}}}, 22309 // int -> BOOL8 map 22310 .bool8Operands = {}, 22311 // int -> QUANT8_SYMM_PER_CHANNEL map 22312 .quant8ChannelOperands = {}, 22313 // int -> QUANT16_ASYMM map 22314 .quant16AsymmOperands = {}, 22315 // int -> QUANT8_SYMM map 22316 .quant8SymmOperands = {}, 22317 }, 22318 //Output(s) 22319 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22320 // int -> Dimensions map 22321 .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 1, 3, 3}}}, 22322 // int -> FLOAT32 map 22323 .float32Operands = {}, 22324 // int -> INT32 map 22325 .int32Operands = {{1, {0}}}, 22326 // int -> QUANT8_ASYMM map 22327 .quant8AsymmOperands = {}, 22328 // int -> QUANT16_SYMM map 22329 .quant16SymmOperands = {}, 22330 // int -> FLOAT16 map 22331 .float16Operands = {{0, {0.0f}}, {2, {0.0f}}}, 22332 // int -> BOOL8 map 22333 .bool8Operands = {}, 22334 // int -> QUANT8_SYMM_PER_CHANNEL map 22335 .quant8ChannelOperands = {}, 22336 // int -> QUANT16_ASYMM map 22337 .quant16AsymmOperands = {}, 22338 // int -> QUANT8_SYMM map 22339 .quant8SymmOperands = {}, 22340 } 22341 }, 22342 }, // End of an example 22343 }; 22344 return examples_zero_sized_dynamic_output_shape_nchw_float16_2; 22345 }; 22346 22347 std::vector<MixedTypedExample>& get_examples_nhwc_5() { 22348 static std::vector<MixedTypedExample> examples_nhwc_5 = { 22349 // Begin of an example 22350 { 22351 .operands = { 22352 //Input(s) 22353 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22354 // int -> Dimensions map 22355 .operandDimensions = {{0, {1, 2, 2, 1}}}, 22356 // int -> FLOAT32 map 22357 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 22358 // int -> INT32 map 22359 .int32Operands = {}, 22360 // int -> QUANT8_ASYMM map 22361 .quant8AsymmOperands = {}, 22362 // int -> QUANT16_SYMM map 22363 .quant16SymmOperands = {}, 22364 // int -> FLOAT16 map 22365 .float16Operands = {}, 22366 // int -> BOOL8 map 22367 .bool8Operands = {}, 22368 // int -> QUANT8_SYMM_PER_CHANNEL map 22369 .quant8ChannelOperands = {}, 22370 // int -> QUANT16_ASYMM map 22371 .quant16AsymmOperands = {}, 22372 // int -> QUANT8_SYMM map 22373 .quant8SymmOperands = {}, 22374 }, 22375 //Output(s) 22376 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22377 // int -> Dimensions map 22378 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22379 // int -> FLOAT32 map 22380 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22381 // int -> INT32 map 22382 .int32Operands = {}, 22383 // int -> QUANT8_ASYMM map 22384 .quant8AsymmOperands = {}, 22385 // int -> QUANT16_SYMM map 22386 .quant16SymmOperands = {}, 22387 // int -> FLOAT16 map 22388 .float16Operands = {}, 22389 // int -> BOOL8 map 22390 .bool8Operands = {}, 22391 // int -> QUANT8_SYMM_PER_CHANNEL map 22392 .quant8ChannelOperands = {}, 22393 // int -> QUANT16_ASYMM map 22394 .quant16AsymmOperands = {}, 22395 // int -> QUANT8_SYMM map 22396 .quant8SymmOperands = {}, 22397 } 22398 }, 22399 }, // End of an example 22400 }; 22401 return examples_nhwc_5; 22402 }; 22403 22404 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_5() { 22405 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_5 = { 22406 // Begin of an example 22407 { 22408 .operands = { 22409 //Input(s) 22410 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22411 // int -> Dimensions map 22412 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22413 // int -> FLOAT32 map 22414 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 22415 // int -> INT32 map 22416 .int32Operands = {}, 22417 // int -> QUANT8_ASYMM map 22418 .quant8AsymmOperands = {}, 22419 // int -> QUANT16_SYMM map 22420 .quant16SymmOperands = {}, 22421 // int -> FLOAT16 map 22422 .float16Operands = {}, 22423 // int -> BOOL8 map 22424 .bool8Operands = {}, 22425 // int -> QUANT8_SYMM_PER_CHANNEL map 22426 .quant8ChannelOperands = {}, 22427 // int -> QUANT16_ASYMM map 22428 .quant16AsymmOperands = {}, 22429 // int -> QUANT8_SYMM map 22430 .quant8SymmOperands = {}, 22431 }, 22432 //Output(s) 22433 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22434 // int -> Dimensions map 22435 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22436 // int -> FLOAT32 map 22437 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22438 // int -> INT32 map 22439 .int32Operands = {}, 22440 // int -> QUANT8_ASYMM map 22441 .quant8AsymmOperands = {}, 22442 // int -> QUANT16_SYMM map 22443 .quant16SymmOperands = {}, 22444 // int -> FLOAT16 map 22445 .float16Operands = {}, 22446 // int -> BOOL8 map 22447 .bool8Operands = {}, 22448 // int -> QUANT8_SYMM_PER_CHANNEL map 22449 .quant8ChannelOperands = {}, 22450 // int -> QUANT16_ASYMM map 22451 .quant16AsymmOperands = {}, 22452 // int -> QUANT8_SYMM map 22453 .quant8SymmOperands = {}, 22454 } 22455 }, 22456 }, // End of an example 22457 }; 22458 return examples_nhwc_weight_as_input_5; 22459 }; 22460 22461 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_5() { 22462 static std::vector<MixedTypedExample> examples_nhwc_relaxed_5 = { 22463 // Begin of an example 22464 { 22465 .operands = { 22466 //Input(s) 22467 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22468 // int -> Dimensions map 22469 .operandDimensions = {{0, {1, 2, 2, 1}}}, 22470 // int -> FLOAT32 map 22471 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 22472 // int -> INT32 map 22473 .int32Operands = {}, 22474 // int -> QUANT8_ASYMM map 22475 .quant8AsymmOperands = {}, 22476 // int -> QUANT16_SYMM map 22477 .quant16SymmOperands = {}, 22478 // int -> FLOAT16 map 22479 .float16Operands = {}, 22480 // int -> BOOL8 map 22481 .bool8Operands = {}, 22482 // int -> QUANT8_SYMM_PER_CHANNEL map 22483 .quant8ChannelOperands = {}, 22484 // int -> QUANT16_ASYMM map 22485 .quant16AsymmOperands = {}, 22486 // int -> QUANT8_SYMM map 22487 .quant8SymmOperands = {}, 22488 }, 22489 //Output(s) 22490 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22491 // int -> Dimensions map 22492 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22493 // int -> FLOAT32 map 22494 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22495 // int -> INT32 map 22496 .int32Operands = {}, 22497 // int -> QUANT8_ASYMM map 22498 .quant8AsymmOperands = {}, 22499 // int -> QUANT16_SYMM map 22500 .quant16SymmOperands = {}, 22501 // int -> FLOAT16 map 22502 .float16Operands = {}, 22503 // int -> BOOL8 map 22504 .bool8Operands = {}, 22505 // int -> QUANT8_SYMM_PER_CHANNEL map 22506 .quant8ChannelOperands = {}, 22507 // int -> QUANT16_ASYMM map 22508 .quant16AsymmOperands = {}, 22509 // int -> QUANT8_SYMM map 22510 .quant8SymmOperands = {}, 22511 } 22512 }, 22513 }, // End of an example 22514 }; 22515 return examples_nhwc_relaxed_5; 22516 }; 22517 22518 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed_weight_as_input_5() { 22519 static std::vector<MixedTypedExample> examples_nhwc_relaxed_weight_as_input_5 = { 22520 // Begin of an example 22521 { 22522 .operands = { 22523 //Input(s) 22524 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22525 // int -> Dimensions map 22526 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22527 // int -> FLOAT32 map 22528 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 22529 // int -> INT32 map 22530 .int32Operands = {}, 22531 // int -> QUANT8_ASYMM map 22532 .quant8AsymmOperands = {}, 22533 // int -> QUANT16_SYMM map 22534 .quant16SymmOperands = {}, 22535 // int -> FLOAT16 map 22536 .float16Operands = {}, 22537 // int -> BOOL8 map 22538 .bool8Operands = {}, 22539 // int -> QUANT8_SYMM_PER_CHANNEL map 22540 .quant8ChannelOperands = {}, 22541 // int -> QUANT16_ASYMM map 22542 .quant16AsymmOperands = {}, 22543 // int -> QUANT8_SYMM map 22544 .quant8SymmOperands = {}, 22545 }, 22546 //Output(s) 22547 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22548 // int -> Dimensions map 22549 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22550 // int -> FLOAT32 map 22551 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22552 // int -> INT32 map 22553 .int32Operands = {}, 22554 // int -> QUANT8_ASYMM map 22555 .quant8AsymmOperands = {}, 22556 // int -> QUANT16_SYMM map 22557 .quant16SymmOperands = {}, 22558 // int -> FLOAT16 map 22559 .float16Operands = {}, 22560 // int -> BOOL8 map 22561 .bool8Operands = {}, 22562 // int -> QUANT8_SYMM_PER_CHANNEL map 22563 .quant8ChannelOperands = {}, 22564 // int -> QUANT16_ASYMM map 22565 .quant16AsymmOperands = {}, 22566 // int -> QUANT8_SYMM map 22567 .quant8SymmOperands = {}, 22568 } 22569 }, 22570 }, // End of an example 22571 }; 22572 return examples_nhwc_relaxed_weight_as_input_5; 22573 }; 22574 22575 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_5() { 22576 static std::vector<MixedTypedExample> examples_nhwc_quant8_5 = { 22577 // Begin of an example 22578 { 22579 .operands = { 22580 //Input(s) 22581 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22582 // int -> Dimensions map 22583 .operandDimensions = {{0, {1, 2, 2, 1}}}, 22584 // int -> FLOAT32 map 22585 .float32Operands = {}, 22586 // int -> INT32 map 22587 .int32Operands = {}, 22588 // int -> QUANT8_ASYMM map 22589 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 22590 // int -> QUANT16_SYMM map 22591 .quant16SymmOperands = {}, 22592 // int -> FLOAT16 map 22593 .float16Operands = {}, 22594 // int -> BOOL8 map 22595 .bool8Operands = {}, 22596 // int -> QUANT8_SYMM_PER_CHANNEL map 22597 .quant8ChannelOperands = {}, 22598 // int -> QUANT16_ASYMM map 22599 .quant16AsymmOperands = {}, 22600 // int -> QUANT8_SYMM map 22601 .quant8SymmOperands = {}, 22602 }, 22603 //Output(s) 22604 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22605 // int -> Dimensions map 22606 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22607 // int -> FLOAT32 map 22608 .float32Operands = {}, 22609 // int -> INT32 map 22610 .int32Operands = {}, 22611 // int -> QUANT8_ASYMM map 22612 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 22613 // int -> QUANT16_SYMM map 22614 .quant16SymmOperands = {}, 22615 // int -> FLOAT16 map 22616 .float16Operands = {}, 22617 // int -> BOOL8 map 22618 .bool8Operands = {}, 22619 // int -> QUANT8_SYMM_PER_CHANNEL map 22620 .quant8ChannelOperands = {}, 22621 // int -> QUANT16_ASYMM map 22622 .quant16AsymmOperands = {}, 22623 // int -> QUANT8_SYMM map 22624 .quant8SymmOperands = {}, 22625 } 22626 }, 22627 }, // End of an example 22628 }; 22629 return examples_nhwc_quant8_5; 22630 }; 22631 22632 std::vector<MixedTypedExample>& get_examples_nhwc_quant8_weight_as_input_5() { 22633 static std::vector<MixedTypedExample> examples_nhwc_quant8_weight_as_input_5 = { 22634 // Begin of an example 22635 { 22636 .operands = { 22637 //Input(s) 22638 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22639 // int -> Dimensions map 22640 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22641 // int -> FLOAT32 map 22642 .float32Operands = {}, 22643 // int -> INT32 map 22644 .int32Operands = {{2, {0}}}, 22645 // int -> QUANT8_ASYMM map 22646 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {132}}}, 22647 // int -> QUANT16_SYMM map 22648 .quant16SymmOperands = {}, 22649 // int -> FLOAT16 map 22650 .float16Operands = {}, 22651 // int -> BOOL8 map 22652 .bool8Operands = {}, 22653 // int -> QUANT8_SYMM_PER_CHANNEL map 22654 .quant8ChannelOperands = {}, 22655 // int -> QUANT16_ASYMM map 22656 .quant16AsymmOperands = {}, 22657 // int -> QUANT8_SYMM map 22658 .quant8SymmOperands = {}, 22659 }, 22660 //Output(s) 22661 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22662 // int -> Dimensions map 22663 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22664 // int -> FLOAT32 map 22665 .float32Operands = {}, 22666 // int -> INT32 map 22667 .int32Operands = {}, 22668 // int -> QUANT8_ASYMM map 22669 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 22670 // int -> QUANT16_SYMM map 22671 .quant16SymmOperands = {}, 22672 // int -> FLOAT16 map 22673 .float16Operands = {}, 22674 // int -> BOOL8 map 22675 .bool8Operands = {}, 22676 // int -> QUANT8_SYMM_PER_CHANNEL map 22677 .quant8ChannelOperands = {}, 22678 // int -> QUANT16_ASYMM map 22679 .quant16AsymmOperands = {}, 22680 // int -> QUANT8_SYMM map 22681 .quant8SymmOperands = {}, 22682 } 22683 }, 22684 }, // End of an example 22685 }; 22686 return examples_nhwc_quant8_weight_as_input_5; 22687 }; 22688 22689 std::vector<MixedTypedExample>& get_examples_nhwc_float16_5() { 22690 static std::vector<MixedTypedExample> examples_nhwc_float16_5 = { 22691 // Begin of an example 22692 { 22693 .operands = { 22694 //Input(s) 22695 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22696 // int -> Dimensions map 22697 .operandDimensions = {{0, {1, 2, 2, 1}}}, 22698 // int -> FLOAT32 map 22699 .float32Operands = {}, 22700 // int -> INT32 map 22701 .int32Operands = {}, 22702 // int -> QUANT8_ASYMM map 22703 .quant8AsymmOperands = {}, 22704 // int -> QUANT16_SYMM map 22705 .quant16SymmOperands = {}, 22706 // int -> FLOAT16 map 22707 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 22708 // int -> BOOL8 map 22709 .bool8Operands = {}, 22710 // int -> QUANT8_SYMM_PER_CHANNEL map 22711 .quant8ChannelOperands = {}, 22712 // int -> QUANT16_ASYMM map 22713 .quant16AsymmOperands = {}, 22714 // int -> QUANT8_SYMM map 22715 .quant8SymmOperands = {}, 22716 }, 22717 //Output(s) 22718 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22719 // int -> Dimensions map 22720 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22721 // int -> FLOAT32 map 22722 .float32Operands = {}, 22723 // int -> INT32 map 22724 .int32Operands = {}, 22725 // int -> QUANT8_ASYMM map 22726 .quant8AsymmOperands = {}, 22727 // int -> QUANT16_SYMM map 22728 .quant16SymmOperands = {}, 22729 // int -> FLOAT16 map 22730 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22731 // int -> BOOL8 map 22732 .bool8Operands = {}, 22733 // int -> QUANT8_SYMM_PER_CHANNEL map 22734 .quant8ChannelOperands = {}, 22735 // int -> QUANT16_ASYMM map 22736 .quant16AsymmOperands = {}, 22737 // int -> QUANT8_SYMM map 22738 .quant8SymmOperands = {}, 22739 } 22740 }, 22741 }, // End of an example 22742 }; 22743 return examples_nhwc_float16_5; 22744 }; 22745 22746 std::vector<MixedTypedExample>& get_examples_nhwc_float16_weight_as_input_5() { 22747 static std::vector<MixedTypedExample> examples_nhwc_float16_weight_as_input_5 = { 22748 // Begin of an example 22749 { 22750 .operands = { 22751 //Input(s) 22752 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22753 // int -> Dimensions map 22754 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22755 // int -> FLOAT32 map 22756 .float32Operands = {}, 22757 // int -> INT32 map 22758 .int32Operands = {}, 22759 // int -> QUANT8_ASYMM map 22760 .quant8AsymmOperands = {}, 22761 // int -> QUANT16_SYMM map 22762 .quant16SymmOperands = {}, 22763 // int -> FLOAT16 map 22764 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 22765 // int -> BOOL8 map 22766 .bool8Operands = {}, 22767 // int -> QUANT8_SYMM_PER_CHANNEL map 22768 .quant8ChannelOperands = {}, 22769 // int -> QUANT16_ASYMM map 22770 .quant16AsymmOperands = {}, 22771 // int -> QUANT8_SYMM map 22772 .quant8SymmOperands = {}, 22773 }, 22774 //Output(s) 22775 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22776 // int -> Dimensions map 22777 .operandDimensions = {{0, {1, 4, 4, 1}}}, 22778 // int -> FLOAT32 map 22779 .float32Operands = {}, 22780 // int -> INT32 map 22781 .int32Operands = {}, 22782 // int -> QUANT8_ASYMM map 22783 .quant8AsymmOperands = {}, 22784 // int -> QUANT16_SYMM map 22785 .quant16SymmOperands = {}, 22786 // int -> FLOAT16 map 22787 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22788 // int -> BOOL8 map 22789 .bool8Operands = {}, 22790 // int -> QUANT8_SYMM_PER_CHANNEL map 22791 .quant8ChannelOperands = {}, 22792 // int -> QUANT16_ASYMM map 22793 .quant16AsymmOperands = {}, 22794 // int -> QUANT8_SYMM map 22795 .quant8SymmOperands = {}, 22796 } 22797 }, 22798 }, // End of an example 22799 }; 22800 return examples_nhwc_float16_weight_as_input_5; 22801 }; 22802 22803 std::vector<MixedTypedExample>& get_examples_nchw_5() { 22804 static std::vector<MixedTypedExample> examples_nchw_5 = { 22805 // Begin of an example 22806 { 22807 .operands = { 22808 //Input(s) 22809 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22810 // int -> Dimensions map 22811 .operandDimensions = {{0, {1, 1, 2, 2}}}, 22812 // int -> FLOAT32 map 22813 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 22814 // int -> INT32 map 22815 .int32Operands = {}, 22816 // int -> QUANT8_ASYMM map 22817 .quant8AsymmOperands = {}, 22818 // int -> QUANT16_SYMM map 22819 .quant16SymmOperands = {}, 22820 // int -> FLOAT16 map 22821 .float16Operands = {}, 22822 // int -> BOOL8 map 22823 .bool8Operands = {}, 22824 // int -> QUANT8_SYMM_PER_CHANNEL map 22825 .quant8ChannelOperands = {}, 22826 // int -> QUANT16_ASYMM map 22827 .quant16AsymmOperands = {}, 22828 // int -> QUANT8_SYMM map 22829 .quant8SymmOperands = {}, 22830 }, 22831 //Output(s) 22832 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22833 // int -> Dimensions map 22834 .operandDimensions = {{0, {1, 1, 4, 4}}}, 22835 // int -> FLOAT32 map 22836 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22837 // int -> INT32 map 22838 .int32Operands = {}, 22839 // int -> QUANT8_ASYMM map 22840 .quant8AsymmOperands = {}, 22841 // int -> QUANT16_SYMM map 22842 .quant16SymmOperands = {}, 22843 // int -> FLOAT16 map 22844 .float16Operands = {}, 22845 // int -> BOOL8 map 22846 .bool8Operands = {}, 22847 // int -> QUANT8_SYMM_PER_CHANNEL map 22848 .quant8ChannelOperands = {}, 22849 // int -> QUANT16_ASYMM map 22850 .quant16AsymmOperands = {}, 22851 // int -> QUANT8_SYMM map 22852 .quant8SymmOperands = {}, 22853 } 22854 }, 22855 }, // End of an example 22856 }; 22857 return examples_nchw_5; 22858 }; 22859 22860 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_5() { 22861 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_5 = { 22862 // Begin of an example 22863 { 22864 .operands = { 22865 //Input(s) 22866 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22867 // int -> Dimensions map 22868 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22869 // int -> FLOAT32 map 22870 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 22871 // int -> INT32 map 22872 .int32Operands = {}, 22873 // int -> QUANT8_ASYMM map 22874 .quant8AsymmOperands = {}, 22875 // int -> QUANT16_SYMM map 22876 .quant16SymmOperands = {}, 22877 // int -> FLOAT16 map 22878 .float16Operands = {}, 22879 // int -> BOOL8 map 22880 .bool8Operands = {}, 22881 // int -> QUANT8_SYMM_PER_CHANNEL map 22882 .quant8ChannelOperands = {}, 22883 // int -> QUANT16_ASYMM map 22884 .quant16AsymmOperands = {}, 22885 // int -> QUANT8_SYMM map 22886 .quant8SymmOperands = {}, 22887 }, 22888 //Output(s) 22889 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22890 // int -> Dimensions map 22891 .operandDimensions = {{0, {1, 1, 4, 4}}}, 22892 // int -> FLOAT32 map 22893 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22894 // int -> INT32 map 22895 .int32Operands = {}, 22896 // int -> QUANT8_ASYMM map 22897 .quant8AsymmOperands = {}, 22898 // int -> QUANT16_SYMM map 22899 .quant16SymmOperands = {}, 22900 // int -> FLOAT16 map 22901 .float16Operands = {}, 22902 // int -> BOOL8 map 22903 .bool8Operands = {}, 22904 // int -> QUANT8_SYMM_PER_CHANNEL map 22905 .quant8ChannelOperands = {}, 22906 // int -> QUANT16_ASYMM map 22907 .quant16AsymmOperands = {}, 22908 // int -> QUANT8_SYMM map 22909 .quant8SymmOperands = {}, 22910 } 22911 }, 22912 }, // End of an example 22913 }; 22914 return examples_nchw_weight_as_input_5; 22915 }; 22916 22917 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_5() { 22918 static std::vector<MixedTypedExample> examples_nchw_relaxed_5 = { 22919 // Begin of an example 22920 { 22921 .operands = { 22922 //Input(s) 22923 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22924 // int -> Dimensions map 22925 .operandDimensions = {{0, {1, 1, 2, 2}}}, 22926 // int -> FLOAT32 map 22927 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 22928 // int -> INT32 map 22929 .int32Operands = {}, 22930 // int -> QUANT8_ASYMM map 22931 .quant8AsymmOperands = {}, 22932 // int -> QUANT16_SYMM map 22933 .quant16SymmOperands = {}, 22934 // int -> FLOAT16 map 22935 .float16Operands = {}, 22936 // int -> BOOL8 map 22937 .bool8Operands = {}, 22938 // int -> QUANT8_SYMM_PER_CHANNEL map 22939 .quant8ChannelOperands = {}, 22940 // int -> QUANT16_ASYMM map 22941 .quant16AsymmOperands = {}, 22942 // int -> QUANT8_SYMM map 22943 .quant8SymmOperands = {}, 22944 }, 22945 //Output(s) 22946 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22947 // int -> Dimensions map 22948 .operandDimensions = {{0, {1, 1, 4, 4}}}, 22949 // int -> FLOAT32 map 22950 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 22951 // int -> INT32 map 22952 .int32Operands = {}, 22953 // int -> QUANT8_ASYMM map 22954 .quant8AsymmOperands = {}, 22955 // int -> QUANT16_SYMM map 22956 .quant16SymmOperands = {}, 22957 // int -> FLOAT16 map 22958 .float16Operands = {}, 22959 // int -> BOOL8 map 22960 .bool8Operands = {}, 22961 // int -> QUANT8_SYMM_PER_CHANNEL map 22962 .quant8ChannelOperands = {}, 22963 // int -> QUANT16_ASYMM map 22964 .quant16AsymmOperands = {}, 22965 // int -> QUANT8_SYMM map 22966 .quant8SymmOperands = {}, 22967 } 22968 }, 22969 }, // End of an example 22970 }; 22971 return examples_nchw_relaxed_5; 22972 }; 22973 22974 std::vector<MixedTypedExample>& get_examples_nchw_relaxed_weight_as_input_5() { 22975 static std::vector<MixedTypedExample> examples_nchw_relaxed_weight_as_input_5 = { 22976 // Begin of an example 22977 { 22978 .operands = { 22979 //Input(s) 22980 { // See tools/test_generator/include/TestHarness.h:MixedTyped 22981 // int -> Dimensions map 22982 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 22983 // int -> FLOAT32 map 22984 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 22985 // int -> INT32 map 22986 .int32Operands = {}, 22987 // int -> QUANT8_ASYMM map 22988 .quant8AsymmOperands = {}, 22989 // int -> QUANT16_SYMM map 22990 .quant16SymmOperands = {}, 22991 // int -> FLOAT16 map 22992 .float16Operands = {}, 22993 // int -> BOOL8 map 22994 .bool8Operands = {}, 22995 // int -> QUANT8_SYMM_PER_CHANNEL map 22996 .quant8ChannelOperands = {}, 22997 // int -> QUANT16_ASYMM map 22998 .quant16AsymmOperands = {}, 22999 // int -> QUANT8_SYMM map 23000 .quant8SymmOperands = {}, 23001 }, 23002 //Output(s) 23003 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23004 // int -> Dimensions map 23005 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23006 // int -> FLOAT32 map 23007 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23008 // int -> INT32 map 23009 .int32Operands = {}, 23010 // int -> QUANT8_ASYMM map 23011 .quant8AsymmOperands = {}, 23012 // int -> QUANT16_SYMM map 23013 .quant16SymmOperands = {}, 23014 // int -> FLOAT16 map 23015 .float16Operands = {}, 23016 // int -> BOOL8 map 23017 .bool8Operands = {}, 23018 // int -> QUANT8_SYMM_PER_CHANNEL map 23019 .quant8ChannelOperands = {}, 23020 // int -> QUANT16_ASYMM map 23021 .quant16AsymmOperands = {}, 23022 // int -> QUANT8_SYMM map 23023 .quant8SymmOperands = {}, 23024 } 23025 }, 23026 }, // End of an example 23027 }; 23028 return examples_nchw_relaxed_weight_as_input_5; 23029 }; 23030 23031 std::vector<MixedTypedExample>& get_examples_nchw_quant8_5() { 23032 static std::vector<MixedTypedExample> examples_nchw_quant8_5 = { 23033 // Begin of an example 23034 { 23035 .operands = { 23036 //Input(s) 23037 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23038 // int -> Dimensions map 23039 .operandDimensions = {{0, {1, 1, 2, 2}}}, 23040 // int -> FLOAT32 map 23041 .float32Operands = {}, 23042 // int -> INT32 map 23043 .int32Operands = {}, 23044 // int -> QUANT8_ASYMM map 23045 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 23046 // int -> QUANT16_SYMM map 23047 .quant16SymmOperands = {}, 23048 // int -> FLOAT16 map 23049 .float16Operands = {}, 23050 // int -> BOOL8 map 23051 .bool8Operands = {}, 23052 // int -> QUANT8_SYMM_PER_CHANNEL map 23053 .quant8ChannelOperands = {}, 23054 // int -> QUANT16_ASYMM map 23055 .quant16AsymmOperands = {}, 23056 // int -> QUANT8_SYMM map 23057 .quant8SymmOperands = {}, 23058 }, 23059 //Output(s) 23060 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23061 // int -> Dimensions map 23062 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23063 // int -> FLOAT32 map 23064 .float32Operands = {}, 23065 // int -> INT32 map 23066 .int32Operands = {}, 23067 // int -> QUANT8_ASYMM map 23068 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 23069 // int -> QUANT16_SYMM map 23070 .quant16SymmOperands = {}, 23071 // int -> FLOAT16 map 23072 .float16Operands = {}, 23073 // int -> BOOL8 map 23074 .bool8Operands = {}, 23075 // int -> QUANT8_SYMM_PER_CHANNEL map 23076 .quant8ChannelOperands = {}, 23077 // int -> QUANT16_ASYMM map 23078 .quant16AsymmOperands = {}, 23079 // int -> QUANT8_SYMM map 23080 .quant8SymmOperands = {}, 23081 } 23082 }, 23083 }, // End of an example 23084 }; 23085 return examples_nchw_quant8_5; 23086 }; 23087 23088 std::vector<MixedTypedExample>& get_examples_nchw_quant8_weight_as_input_5() { 23089 static std::vector<MixedTypedExample> examples_nchw_quant8_weight_as_input_5 = { 23090 // Begin of an example 23091 { 23092 .operands = { 23093 //Input(s) 23094 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23095 // int -> Dimensions map 23096 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23097 // int -> FLOAT32 map 23098 .float32Operands = {}, 23099 // int -> INT32 map 23100 .int32Operands = {{2, {0}}}, 23101 // int -> QUANT8_ASYMM map 23102 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {132}}}, 23103 // int -> QUANT16_SYMM map 23104 .quant16SymmOperands = {}, 23105 // int -> FLOAT16 map 23106 .float16Operands = {}, 23107 // int -> BOOL8 map 23108 .bool8Operands = {}, 23109 // int -> QUANT8_SYMM_PER_CHANNEL map 23110 .quant8ChannelOperands = {}, 23111 // int -> QUANT16_ASYMM map 23112 .quant16AsymmOperands = {}, 23113 // int -> QUANT8_SYMM map 23114 .quant8SymmOperands = {}, 23115 }, 23116 //Output(s) 23117 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23118 // int -> Dimensions map 23119 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23120 // int -> FLOAT32 map 23121 .float32Operands = {}, 23122 // int -> INT32 map 23123 .int32Operands = {}, 23124 // int -> QUANT8_ASYMM map 23125 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 23126 // int -> QUANT16_SYMM map 23127 .quant16SymmOperands = {}, 23128 // int -> FLOAT16 map 23129 .float16Operands = {}, 23130 // int -> BOOL8 map 23131 .bool8Operands = {}, 23132 // int -> QUANT8_SYMM_PER_CHANNEL map 23133 .quant8ChannelOperands = {}, 23134 // int -> QUANT16_ASYMM map 23135 .quant16AsymmOperands = {}, 23136 // int -> QUANT8_SYMM map 23137 .quant8SymmOperands = {}, 23138 } 23139 }, 23140 }, // End of an example 23141 }; 23142 return examples_nchw_quant8_weight_as_input_5; 23143 }; 23144 23145 std::vector<MixedTypedExample>& get_examples_nchw_float16_5() { 23146 static std::vector<MixedTypedExample> examples_nchw_float16_5 = { 23147 // Begin of an example 23148 { 23149 .operands = { 23150 //Input(s) 23151 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23152 // int -> Dimensions map 23153 .operandDimensions = {{0, {1, 1, 2, 2}}}, 23154 // int -> FLOAT32 map 23155 .float32Operands = {}, 23156 // int -> INT32 map 23157 .int32Operands = {}, 23158 // int -> QUANT8_ASYMM map 23159 .quant8AsymmOperands = {}, 23160 // int -> QUANT16_SYMM map 23161 .quant16SymmOperands = {}, 23162 // int -> FLOAT16 map 23163 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23164 // int -> BOOL8 map 23165 .bool8Operands = {}, 23166 // int -> QUANT8_SYMM_PER_CHANNEL map 23167 .quant8ChannelOperands = {}, 23168 // int -> QUANT16_ASYMM map 23169 .quant16AsymmOperands = {}, 23170 // int -> QUANT8_SYMM map 23171 .quant8SymmOperands = {}, 23172 }, 23173 //Output(s) 23174 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23175 // int -> Dimensions map 23176 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23177 // int -> FLOAT32 map 23178 .float32Operands = {}, 23179 // int -> INT32 map 23180 .int32Operands = {}, 23181 // int -> QUANT8_ASYMM map 23182 .quant8AsymmOperands = {}, 23183 // int -> QUANT16_SYMM map 23184 .quant16SymmOperands = {}, 23185 // int -> FLOAT16 map 23186 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23187 // int -> BOOL8 map 23188 .bool8Operands = {}, 23189 // int -> QUANT8_SYMM_PER_CHANNEL map 23190 .quant8ChannelOperands = {}, 23191 // int -> QUANT16_ASYMM map 23192 .quant16AsymmOperands = {}, 23193 // int -> QUANT8_SYMM map 23194 .quant8SymmOperands = {}, 23195 } 23196 }, 23197 }, // End of an example 23198 }; 23199 return examples_nchw_float16_5; 23200 }; 23201 23202 std::vector<MixedTypedExample>& get_examples_nchw_float16_weight_as_input_5() { 23203 static std::vector<MixedTypedExample> examples_nchw_float16_weight_as_input_5 = { 23204 // Begin of an example 23205 { 23206 .operands = { 23207 //Input(s) 23208 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23209 // int -> Dimensions map 23210 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23211 // int -> FLOAT32 map 23212 .float32Operands = {}, 23213 // int -> INT32 map 23214 .int32Operands = {}, 23215 // int -> QUANT8_ASYMM map 23216 .quant8AsymmOperands = {}, 23217 // int -> QUANT16_SYMM map 23218 .quant16SymmOperands = {}, 23219 // int -> FLOAT16 map 23220 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23221 // int -> BOOL8 map 23222 .bool8Operands = {}, 23223 // int -> QUANT8_SYMM_PER_CHANNEL map 23224 .quant8ChannelOperands = {}, 23225 // int -> QUANT16_ASYMM map 23226 .quant16AsymmOperands = {}, 23227 // int -> QUANT8_SYMM map 23228 .quant8SymmOperands = {}, 23229 }, 23230 //Output(s) 23231 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23232 // int -> Dimensions map 23233 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23234 // int -> FLOAT32 map 23235 .float32Operands = {}, 23236 // int -> INT32 map 23237 .int32Operands = {}, 23238 // int -> QUANT8_ASYMM map 23239 .quant8AsymmOperands = {}, 23240 // int -> QUANT16_SYMM map 23241 .quant16SymmOperands = {}, 23242 // int -> FLOAT16 map 23243 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23244 // int -> BOOL8 map 23245 .bool8Operands = {}, 23246 // int -> QUANT8_SYMM_PER_CHANNEL map 23247 .quant8ChannelOperands = {}, 23248 // int -> QUANT16_ASYMM map 23249 .quant16AsymmOperands = {}, 23250 // int -> QUANT8_SYMM map 23251 .quant8SymmOperands = {}, 23252 } 23253 }, 23254 }, // End of an example 23255 }; 23256 return examples_nchw_float16_weight_as_input_5; 23257 }; 23258 23259 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_5() { 23260 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_5 = { 23261 // Begin of an example 23262 { 23263 .operands = { 23264 //Input(s) 23265 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23266 // int -> Dimensions map 23267 .operandDimensions = {{0, {1, 2, 2, 1}}}, 23268 // int -> FLOAT32 map 23269 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23270 // int -> INT32 map 23271 .int32Operands = {}, 23272 // int -> QUANT8_ASYMM map 23273 .quant8AsymmOperands = {}, 23274 // int -> QUANT16_SYMM map 23275 .quant16SymmOperands = {}, 23276 // int -> FLOAT16 map 23277 .float16Operands = {}, 23278 // int -> BOOL8 map 23279 .bool8Operands = {}, 23280 // int -> QUANT8_SYMM_PER_CHANNEL map 23281 .quant8ChannelOperands = {}, 23282 // int -> QUANT16_ASYMM map 23283 .quant16AsymmOperands = {}, 23284 // int -> QUANT8_SYMM map 23285 .quant8SymmOperands = {}, 23286 }, 23287 //Output(s) 23288 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23289 // int -> Dimensions map 23290 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23291 // int -> FLOAT32 map 23292 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23293 // int -> INT32 map 23294 .int32Operands = {}, 23295 // int -> QUANT8_ASYMM map 23296 .quant8AsymmOperands = {}, 23297 // int -> QUANT16_SYMM map 23298 .quant16SymmOperands = {}, 23299 // int -> FLOAT16 map 23300 .float16Operands = {}, 23301 // int -> BOOL8 map 23302 .bool8Operands = {}, 23303 // int -> QUANT8_SYMM_PER_CHANNEL map 23304 .quant8ChannelOperands = {}, 23305 // int -> QUANT16_ASYMM map 23306 .quant16AsymmOperands = {}, 23307 // int -> QUANT8_SYMM map 23308 .quant8SymmOperands = {}, 23309 } 23310 }, 23311 }, // End of an example 23312 }; 23313 return examples_dynamic_output_shape_nhwc_5; 23314 }; 23315 23316 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_5() { 23317 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_5 = { 23318 // Begin of an example 23319 { 23320 .operands = { 23321 //Input(s) 23322 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23323 // int -> Dimensions map 23324 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23325 // int -> FLOAT32 map 23326 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23327 // int -> INT32 map 23328 .int32Operands = {}, 23329 // int -> QUANT8_ASYMM map 23330 .quant8AsymmOperands = {}, 23331 // int -> QUANT16_SYMM map 23332 .quant16SymmOperands = {}, 23333 // int -> FLOAT16 map 23334 .float16Operands = {}, 23335 // int -> BOOL8 map 23336 .bool8Operands = {}, 23337 // int -> QUANT8_SYMM_PER_CHANNEL map 23338 .quant8ChannelOperands = {}, 23339 // int -> QUANT16_ASYMM map 23340 .quant16AsymmOperands = {}, 23341 // int -> QUANT8_SYMM map 23342 .quant8SymmOperands = {}, 23343 }, 23344 //Output(s) 23345 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23346 // int -> Dimensions map 23347 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23348 // int -> FLOAT32 map 23349 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23350 // int -> INT32 map 23351 .int32Operands = {}, 23352 // int -> QUANT8_ASYMM map 23353 .quant8AsymmOperands = {}, 23354 // int -> QUANT16_SYMM map 23355 .quant16SymmOperands = {}, 23356 // int -> FLOAT16 map 23357 .float16Operands = {}, 23358 // int -> BOOL8 map 23359 .bool8Operands = {}, 23360 // int -> QUANT8_SYMM_PER_CHANNEL map 23361 .quant8ChannelOperands = {}, 23362 // int -> QUANT16_ASYMM map 23363 .quant16AsymmOperands = {}, 23364 // int -> QUANT8_SYMM map 23365 .quant8SymmOperands = {}, 23366 } 23367 }, 23368 }, // End of an example 23369 }; 23370 return examples_dynamic_output_shape_nhwc_weight_as_input_5; 23371 }; 23372 23373 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_5() { 23374 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_5 = { 23375 // Begin of an example 23376 { 23377 .operands = { 23378 //Input(s) 23379 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23380 // int -> Dimensions map 23381 .operandDimensions = {{0, {1, 2, 2, 1}}}, 23382 // int -> FLOAT32 map 23383 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23384 // int -> INT32 map 23385 .int32Operands = {}, 23386 // int -> QUANT8_ASYMM map 23387 .quant8AsymmOperands = {}, 23388 // int -> QUANT16_SYMM map 23389 .quant16SymmOperands = {}, 23390 // int -> FLOAT16 map 23391 .float16Operands = {}, 23392 // int -> BOOL8 map 23393 .bool8Operands = {}, 23394 // int -> QUANT8_SYMM_PER_CHANNEL map 23395 .quant8ChannelOperands = {}, 23396 // int -> QUANT16_ASYMM map 23397 .quant16AsymmOperands = {}, 23398 // int -> QUANT8_SYMM map 23399 .quant8SymmOperands = {}, 23400 }, 23401 //Output(s) 23402 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23403 // int -> Dimensions map 23404 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23405 // int -> FLOAT32 map 23406 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23407 // int -> INT32 map 23408 .int32Operands = {}, 23409 // int -> QUANT8_ASYMM map 23410 .quant8AsymmOperands = {}, 23411 // int -> QUANT16_SYMM map 23412 .quant16SymmOperands = {}, 23413 // int -> FLOAT16 map 23414 .float16Operands = {}, 23415 // int -> BOOL8 map 23416 .bool8Operands = {}, 23417 // int -> QUANT8_SYMM_PER_CHANNEL map 23418 .quant8ChannelOperands = {}, 23419 // int -> QUANT16_ASYMM map 23420 .quant16AsymmOperands = {}, 23421 // int -> QUANT8_SYMM map 23422 .quant8SymmOperands = {}, 23423 } 23424 }, 23425 }, // End of an example 23426 }; 23427 return examples_dynamic_output_shape_nhwc_relaxed_5; 23428 }; 23429 23430 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_5() { 23431 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_5 = { 23432 // Begin of an example 23433 { 23434 .operands = { 23435 //Input(s) 23436 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23437 // int -> Dimensions map 23438 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23439 // int -> FLOAT32 map 23440 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23441 // int -> INT32 map 23442 .int32Operands = {}, 23443 // int -> QUANT8_ASYMM map 23444 .quant8AsymmOperands = {}, 23445 // int -> QUANT16_SYMM map 23446 .quant16SymmOperands = {}, 23447 // int -> FLOAT16 map 23448 .float16Operands = {}, 23449 // int -> BOOL8 map 23450 .bool8Operands = {}, 23451 // int -> QUANT8_SYMM_PER_CHANNEL map 23452 .quant8ChannelOperands = {}, 23453 // int -> QUANT16_ASYMM map 23454 .quant16AsymmOperands = {}, 23455 // int -> QUANT8_SYMM map 23456 .quant8SymmOperands = {}, 23457 }, 23458 //Output(s) 23459 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23460 // int -> Dimensions map 23461 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23462 // int -> FLOAT32 map 23463 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23464 // int -> INT32 map 23465 .int32Operands = {}, 23466 // int -> QUANT8_ASYMM map 23467 .quant8AsymmOperands = {}, 23468 // int -> QUANT16_SYMM map 23469 .quant16SymmOperands = {}, 23470 // int -> FLOAT16 map 23471 .float16Operands = {}, 23472 // int -> BOOL8 map 23473 .bool8Operands = {}, 23474 // int -> QUANT8_SYMM_PER_CHANNEL map 23475 .quant8ChannelOperands = {}, 23476 // int -> QUANT16_ASYMM map 23477 .quant16AsymmOperands = {}, 23478 // int -> QUANT8_SYMM map 23479 .quant8SymmOperands = {}, 23480 } 23481 }, 23482 }, // End of an example 23483 }; 23484 return examples_dynamic_output_shape_nhwc_relaxed_weight_as_input_5; 23485 }; 23486 23487 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_5() { 23488 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_5 = { 23489 // Begin of an example 23490 { 23491 .operands = { 23492 //Input(s) 23493 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23494 // int -> Dimensions map 23495 .operandDimensions = {{0, {1, 2, 2, 1}}}, 23496 // int -> FLOAT32 map 23497 .float32Operands = {}, 23498 // int -> INT32 map 23499 .int32Operands = {}, 23500 // int -> QUANT8_ASYMM map 23501 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 23502 // int -> QUANT16_SYMM map 23503 .quant16SymmOperands = {}, 23504 // int -> FLOAT16 map 23505 .float16Operands = {}, 23506 // int -> BOOL8 map 23507 .bool8Operands = {}, 23508 // int -> QUANT8_SYMM_PER_CHANNEL map 23509 .quant8ChannelOperands = {}, 23510 // int -> QUANT16_ASYMM map 23511 .quant16AsymmOperands = {}, 23512 // int -> QUANT8_SYMM map 23513 .quant8SymmOperands = {}, 23514 }, 23515 //Output(s) 23516 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23517 // int -> Dimensions map 23518 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23519 // int -> FLOAT32 map 23520 .float32Operands = {}, 23521 // int -> INT32 map 23522 .int32Operands = {}, 23523 // int -> QUANT8_ASYMM map 23524 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 23525 // int -> QUANT16_SYMM map 23526 .quant16SymmOperands = {}, 23527 // int -> FLOAT16 map 23528 .float16Operands = {}, 23529 // int -> BOOL8 map 23530 .bool8Operands = {}, 23531 // int -> QUANT8_SYMM_PER_CHANNEL map 23532 .quant8ChannelOperands = {}, 23533 // int -> QUANT16_ASYMM map 23534 .quant16AsymmOperands = {}, 23535 // int -> QUANT8_SYMM map 23536 .quant8SymmOperands = {}, 23537 } 23538 }, 23539 }, // End of an example 23540 }; 23541 return examples_dynamic_output_shape_nhwc_quant8_5; 23542 }; 23543 23544 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8_weight_as_input_5() { 23545 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8_weight_as_input_5 = { 23546 // Begin of an example 23547 { 23548 .operands = { 23549 //Input(s) 23550 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23551 // int -> Dimensions map 23552 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23553 // int -> FLOAT32 map 23554 .float32Operands = {}, 23555 // int -> INT32 map 23556 .int32Operands = {{2, {0}}}, 23557 // int -> QUANT8_ASYMM map 23558 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {132}}}, 23559 // int -> QUANT16_SYMM map 23560 .quant16SymmOperands = {}, 23561 // int -> FLOAT16 map 23562 .float16Operands = {}, 23563 // int -> BOOL8 map 23564 .bool8Operands = {}, 23565 // int -> QUANT8_SYMM_PER_CHANNEL map 23566 .quant8ChannelOperands = {}, 23567 // int -> QUANT16_ASYMM map 23568 .quant16AsymmOperands = {}, 23569 // int -> QUANT8_SYMM map 23570 .quant8SymmOperands = {}, 23571 }, 23572 //Output(s) 23573 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23574 // int -> Dimensions map 23575 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23576 // int -> FLOAT32 map 23577 .float32Operands = {}, 23578 // int -> INT32 map 23579 .int32Operands = {}, 23580 // int -> QUANT8_ASYMM map 23581 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 23582 // int -> QUANT16_SYMM map 23583 .quant16SymmOperands = {}, 23584 // int -> FLOAT16 map 23585 .float16Operands = {}, 23586 // int -> BOOL8 map 23587 .bool8Operands = {}, 23588 // int -> QUANT8_SYMM_PER_CHANNEL map 23589 .quant8ChannelOperands = {}, 23590 // int -> QUANT16_ASYMM map 23591 .quant16AsymmOperands = {}, 23592 // int -> QUANT8_SYMM map 23593 .quant8SymmOperands = {}, 23594 } 23595 }, 23596 }, // End of an example 23597 }; 23598 return examples_dynamic_output_shape_nhwc_quant8_weight_as_input_5; 23599 }; 23600 23601 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_5() { 23602 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_5 = { 23603 // Begin of an example 23604 { 23605 .operands = { 23606 //Input(s) 23607 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23608 // int -> Dimensions map 23609 .operandDimensions = {{0, {1, 2, 2, 1}}}, 23610 // int -> FLOAT32 map 23611 .float32Operands = {}, 23612 // int -> INT32 map 23613 .int32Operands = {}, 23614 // int -> QUANT8_ASYMM map 23615 .quant8AsymmOperands = {}, 23616 // int -> QUANT16_SYMM map 23617 .quant16SymmOperands = {}, 23618 // int -> FLOAT16 map 23619 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23620 // int -> BOOL8 map 23621 .bool8Operands = {}, 23622 // int -> QUANT8_SYMM_PER_CHANNEL map 23623 .quant8ChannelOperands = {}, 23624 // int -> QUANT16_ASYMM map 23625 .quant16AsymmOperands = {}, 23626 // int -> QUANT8_SYMM map 23627 .quant8SymmOperands = {}, 23628 }, 23629 //Output(s) 23630 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23631 // int -> Dimensions map 23632 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23633 // int -> FLOAT32 map 23634 .float32Operands = {}, 23635 // int -> INT32 map 23636 .int32Operands = {}, 23637 // int -> QUANT8_ASYMM map 23638 .quant8AsymmOperands = {}, 23639 // int -> QUANT16_SYMM map 23640 .quant16SymmOperands = {}, 23641 // int -> FLOAT16 map 23642 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23643 // int -> BOOL8 map 23644 .bool8Operands = {}, 23645 // int -> QUANT8_SYMM_PER_CHANNEL map 23646 .quant8ChannelOperands = {}, 23647 // int -> QUANT16_ASYMM map 23648 .quant16AsymmOperands = {}, 23649 // int -> QUANT8_SYMM map 23650 .quant8SymmOperands = {}, 23651 } 23652 }, 23653 }, // End of an example 23654 }; 23655 return examples_dynamic_output_shape_nhwc_float16_5; 23656 }; 23657 23658 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16_weight_as_input_5() { 23659 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16_weight_as_input_5 = { 23660 // Begin of an example 23661 { 23662 .operands = { 23663 //Input(s) 23664 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23665 // int -> Dimensions map 23666 .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23667 // int -> FLOAT32 map 23668 .float32Operands = {}, 23669 // int -> INT32 map 23670 .int32Operands = {}, 23671 // int -> QUANT8_ASYMM map 23672 .quant8AsymmOperands = {}, 23673 // int -> QUANT16_SYMM map 23674 .quant16SymmOperands = {}, 23675 // int -> FLOAT16 map 23676 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23677 // int -> BOOL8 map 23678 .bool8Operands = {}, 23679 // int -> QUANT8_SYMM_PER_CHANNEL map 23680 .quant8ChannelOperands = {}, 23681 // int -> QUANT16_ASYMM map 23682 .quant16AsymmOperands = {}, 23683 // int -> QUANT8_SYMM map 23684 .quant8SymmOperands = {}, 23685 }, 23686 //Output(s) 23687 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23688 // int -> Dimensions map 23689 .operandDimensions = {{0, {1, 4, 4, 1}}}, 23690 // int -> FLOAT32 map 23691 .float32Operands = {}, 23692 // int -> INT32 map 23693 .int32Operands = {}, 23694 // int -> QUANT8_ASYMM map 23695 .quant8AsymmOperands = {}, 23696 // int -> QUANT16_SYMM map 23697 .quant16SymmOperands = {}, 23698 // int -> FLOAT16 map 23699 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23700 // int -> BOOL8 map 23701 .bool8Operands = {}, 23702 // int -> QUANT8_SYMM_PER_CHANNEL map 23703 .quant8ChannelOperands = {}, 23704 // int -> QUANT16_ASYMM map 23705 .quant16AsymmOperands = {}, 23706 // int -> QUANT8_SYMM map 23707 .quant8SymmOperands = {}, 23708 } 23709 }, 23710 }, // End of an example 23711 }; 23712 return examples_dynamic_output_shape_nhwc_float16_weight_as_input_5; 23713 }; 23714 23715 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_5() { 23716 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_5 = { 23717 // Begin of an example 23718 { 23719 .operands = { 23720 //Input(s) 23721 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23722 // int -> Dimensions map 23723 .operandDimensions = {{0, {1, 1, 2, 2}}}, 23724 // int -> FLOAT32 map 23725 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23726 // int -> INT32 map 23727 .int32Operands = {}, 23728 // int -> QUANT8_ASYMM map 23729 .quant8AsymmOperands = {}, 23730 // int -> QUANT16_SYMM map 23731 .quant16SymmOperands = {}, 23732 // int -> FLOAT16 map 23733 .float16Operands = {}, 23734 // int -> BOOL8 map 23735 .bool8Operands = {}, 23736 // int -> QUANT8_SYMM_PER_CHANNEL map 23737 .quant8ChannelOperands = {}, 23738 // int -> QUANT16_ASYMM map 23739 .quant16AsymmOperands = {}, 23740 // int -> QUANT8_SYMM map 23741 .quant8SymmOperands = {}, 23742 }, 23743 //Output(s) 23744 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23745 // int -> Dimensions map 23746 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23747 // int -> FLOAT32 map 23748 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23749 // int -> INT32 map 23750 .int32Operands = {}, 23751 // int -> QUANT8_ASYMM map 23752 .quant8AsymmOperands = {}, 23753 // int -> QUANT16_SYMM map 23754 .quant16SymmOperands = {}, 23755 // int -> FLOAT16 map 23756 .float16Operands = {}, 23757 // int -> BOOL8 map 23758 .bool8Operands = {}, 23759 // int -> QUANT8_SYMM_PER_CHANNEL map 23760 .quant8ChannelOperands = {}, 23761 // int -> QUANT16_ASYMM map 23762 .quant16AsymmOperands = {}, 23763 // int -> QUANT8_SYMM map 23764 .quant8SymmOperands = {}, 23765 } 23766 }, 23767 }, // End of an example 23768 }; 23769 return examples_dynamic_output_shape_nchw_5; 23770 }; 23771 23772 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_5() { 23773 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_5 = { 23774 // Begin of an example 23775 { 23776 .operands = { 23777 //Input(s) 23778 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23779 // int -> Dimensions map 23780 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23781 // int -> FLOAT32 map 23782 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23783 // int -> INT32 map 23784 .int32Operands = {}, 23785 // int -> QUANT8_ASYMM map 23786 .quant8AsymmOperands = {}, 23787 // int -> QUANT16_SYMM map 23788 .quant16SymmOperands = {}, 23789 // int -> FLOAT16 map 23790 .float16Operands = {}, 23791 // int -> BOOL8 map 23792 .bool8Operands = {}, 23793 // int -> QUANT8_SYMM_PER_CHANNEL map 23794 .quant8ChannelOperands = {}, 23795 // int -> QUANT16_ASYMM map 23796 .quant16AsymmOperands = {}, 23797 // int -> QUANT8_SYMM map 23798 .quant8SymmOperands = {}, 23799 }, 23800 //Output(s) 23801 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23802 // int -> Dimensions map 23803 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23804 // int -> FLOAT32 map 23805 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23806 // int -> INT32 map 23807 .int32Operands = {}, 23808 // int -> QUANT8_ASYMM map 23809 .quant8AsymmOperands = {}, 23810 // int -> QUANT16_SYMM map 23811 .quant16SymmOperands = {}, 23812 // int -> FLOAT16 map 23813 .float16Operands = {}, 23814 // int -> BOOL8 map 23815 .bool8Operands = {}, 23816 // int -> QUANT8_SYMM_PER_CHANNEL map 23817 .quant8ChannelOperands = {}, 23818 // int -> QUANT16_ASYMM map 23819 .quant16AsymmOperands = {}, 23820 // int -> QUANT8_SYMM map 23821 .quant8SymmOperands = {}, 23822 } 23823 }, 23824 }, // End of an example 23825 }; 23826 return examples_dynamic_output_shape_nchw_weight_as_input_5; 23827 }; 23828 23829 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_5() { 23830 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_5 = { 23831 // Begin of an example 23832 { 23833 .operands = { 23834 //Input(s) 23835 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23836 // int -> Dimensions map 23837 .operandDimensions = {{0, {1, 1, 2, 2}}}, 23838 // int -> FLOAT32 map 23839 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 23840 // int -> INT32 map 23841 .int32Operands = {}, 23842 // int -> QUANT8_ASYMM map 23843 .quant8AsymmOperands = {}, 23844 // int -> QUANT16_SYMM map 23845 .quant16SymmOperands = {}, 23846 // int -> FLOAT16 map 23847 .float16Operands = {}, 23848 // int -> BOOL8 map 23849 .bool8Operands = {}, 23850 // int -> QUANT8_SYMM_PER_CHANNEL map 23851 .quant8ChannelOperands = {}, 23852 // int -> QUANT16_ASYMM map 23853 .quant16AsymmOperands = {}, 23854 // int -> QUANT8_SYMM map 23855 .quant8SymmOperands = {}, 23856 }, 23857 //Output(s) 23858 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23859 // int -> Dimensions map 23860 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23861 // int -> FLOAT32 map 23862 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23863 // int -> INT32 map 23864 .int32Operands = {}, 23865 // int -> QUANT8_ASYMM map 23866 .quant8AsymmOperands = {}, 23867 // int -> QUANT16_SYMM map 23868 .quant16SymmOperands = {}, 23869 // int -> FLOAT16 map 23870 .float16Operands = {}, 23871 // int -> BOOL8 map 23872 .bool8Operands = {}, 23873 // int -> QUANT8_SYMM_PER_CHANNEL map 23874 .quant8ChannelOperands = {}, 23875 // int -> QUANT16_ASYMM map 23876 .quant16AsymmOperands = {}, 23877 // int -> QUANT8_SYMM map 23878 .quant8SymmOperands = {}, 23879 } 23880 }, 23881 }, // End of an example 23882 }; 23883 return examples_dynamic_output_shape_nchw_relaxed_5; 23884 }; 23885 23886 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed_weight_as_input_5() { 23887 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed_weight_as_input_5 = { 23888 // Begin of an example 23889 { 23890 .operands = { 23891 //Input(s) 23892 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23893 // int -> Dimensions map 23894 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 23895 // int -> FLOAT32 map 23896 .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 23897 // int -> INT32 map 23898 .int32Operands = {}, 23899 // int -> QUANT8_ASYMM map 23900 .quant8AsymmOperands = {}, 23901 // int -> QUANT16_SYMM map 23902 .quant16SymmOperands = {}, 23903 // int -> FLOAT16 map 23904 .float16Operands = {}, 23905 // int -> BOOL8 map 23906 .bool8Operands = {}, 23907 // int -> QUANT8_SYMM_PER_CHANNEL map 23908 .quant8ChannelOperands = {}, 23909 // int -> QUANT16_ASYMM map 23910 .quant16AsymmOperands = {}, 23911 // int -> QUANT8_SYMM map 23912 .quant8SymmOperands = {}, 23913 }, 23914 //Output(s) 23915 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23916 // int -> Dimensions map 23917 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23918 // int -> FLOAT32 map 23919 .float32Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 23920 // int -> INT32 map 23921 .int32Operands = {}, 23922 // int -> QUANT8_ASYMM map 23923 .quant8AsymmOperands = {}, 23924 // int -> QUANT16_SYMM map 23925 .quant16SymmOperands = {}, 23926 // int -> FLOAT16 map 23927 .float16Operands = {}, 23928 // int -> BOOL8 map 23929 .bool8Operands = {}, 23930 // int -> QUANT8_SYMM_PER_CHANNEL map 23931 .quant8ChannelOperands = {}, 23932 // int -> QUANT16_ASYMM map 23933 .quant16AsymmOperands = {}, 23934 // int -> QUANT8_SYMM map 23935 .quant8SymmOperands = {}, 23936 } 23937 }, 23938 }, // End of an example 23939 }; 23940 return examples_dynamic_output_shape_nchw_relaxed_weight_as_input_5; 23941 }; 23942 23943 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_5() { 23944 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_5 = { 23945 // Begin of an example 23946 { 23947 .operands = { 23948 //Input(s) 23949 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23950 // int -> Dimensions map 23951 .operandDimensions = {{0, {1, 1, 2, 2}}}, 23952 // int -> FLOAT32 map 23953 .float32Operands = {}, 23954 // int -> INT32 map 23955 .int32Operands = {}, 23956 // int -> QUANT8_ASYMM map 23957 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}}, 23958 // int -> QUANT16_SYMM map 23959 .quant16SymmOperands = {}, 23960 // int -> FLOAT16 map 23961 .float16Operands = {}, 23962 // int -> BOOL8 map 23963 .bool8Operands = {}, 23964 // int -> QUANT8_SYMM_PER_CHANNEL map 23965 .quant8ChannelOperands = {}, 23966 // int -> QUANT16_ASYMM map 23967 .quant16AsymmOperands = {}, 23968 // int -> QUANT8_SYMM map 23969 .quant8SymmOperands = {}, 23970 }, 23971 //Output(s) 23972 { // See tools/test_generator/include/TestHarness.h:MixedTyped 23973 // int -> Dimensions map 23974 .operandDimensions = {{0, {1, 1, 4, 4}}}, 23975 // int -> FLOAT32 map 23976 .float32Operands = {}, 23977 // int -> INT32 map 23978 .int32Operands = {}, 23979 // int -> QUANT8_ASYMM map 23980 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 23981 // int -> QUANT16_SYMM map 23982 .quant16SymmOperands = {}, 23983 // int -> FLOAT16 map 23984 .float16Operands = {}, 23985 // int -> BOOL8 map 23986 .bool8Operands = {}, 23987 // int -> QUANT8_SYMM_PER_CHANNEL map 23988 .quant8ChannelOperands = {}, 23989 // int -> QUANT16_ASYMM map 23990 .quant16AsymmOperands = {}, 23991 // int -> QUANT8_SYMM map 23992 .quant8SymmOperands = {}, 23993 } 23994 }, 23995 }, // End of an example 23996 }; 23997 return examples_dynamic_output_shape_nchw_quant8_5; 23998 }; 23999 24000 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8_weight_as_input_5() { 24001 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8_weight_as_input_5 = { 24002 // Begin of an example 24003 { 24004 .operands = { 24005 //Input(s) 24006 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24007 // int -> Dimensions map 24008 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 24009 // int -> FLOAT32 map 24010 .float32Operands = {}, 24011 // int -> INT32 map 24012 .int32Operands = {{2, {0}}}, 24013 // int -> QUANT8_ASYMM map 24014 .quant8AsymmOperands = {{0, {102, 104, 106, 108}}, {1, {132}}}, 24015 // int -> QUANT16_SYMM map 24016 .quant16SymmOperands = {}, 24017 // int -> FLOAT16 map 24018 .float16Operands = {}, 24019 // int -> BOOL8 map 24020 .bool8Operands = {}, 24021 // int -> QUANT8_SYMM_PER_CHANNEL map 24022 .quant8ChannelOperands = {}, 24023 // int -> QUANT16_ASYMM map 24024 .quant16AsymmOperands = {}, 24025 // int -> QUANT8_SYMM map 24026 .quant8SymmOperands = {}, 24027 }, 24028 //Output(s) 24029 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24030 // int -> Dimensions map 24031 .operandDimensions = {{0, {1, 1, 4, 4}}}, 24032 // int -> FLOAT32 map 24033 .float32Operands = {}, 24034 // int -> INT32 map 24035 .int32Operands = {}, 24036 // int -> QUANT8_ASYMM map 24037 .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}}, 24038 // int -> QUANT16_SYMM map 24039 .quant16SymmOperands = {}, 24040 // int -> FLOAT16 map 24041 .float16Operands = {}, 24042 // int -> BOOL8 map 24043 .bool8Operands = {}, 24044 // int -> QUANT8_SYMM_PER_CHANNEL map 24045 .quant8ChannelOperands = {}, 24046 // int -> QUANT16_ASYMM map 24047 .quant16AsymmOperands = {}, 24048 // int -> QUANT8_SYMM map 24049 .quant8SymmOperands = {}, 24050 } 24051 }, 24052 }, // End of an example 24053 }; 24054 return examples_dynamic_output_shape_nchw_quant8_weight_as_input_5; 24055 }; 24056 24057 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_5() { 24058 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_5 = { 24059 // Begin of an example 24060 { 24061 .operands = { 24062 //Input(s) 24063 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24064 // int -> Dimensions map 24065 .operandDimensions = {{0, {1, 1, 2, 2}}}, 24066 // int -> FLOAT32 map 24067 .float32Operands = {}, 24068 // int -> INT32 map 24069 .int32Operands = {}, 24070 // int -> QUANT8_ASYMM map 24071 .quant8AsymmOperands = {}, 24072 // int -> QUANT16_SYMM map 24073 .quant16SymmOperands = {}, 24074 // int -> FLOAT16 map 24075 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}}, 24076 // int -> BOOL8 map 24077 .bool8Operands = {}, 24078 // int -> QUANT8_SYMM_PER_CHANNEL map 24079 .quant8ChannelOperands = {}, 24080 // int -> QUANT16_ASYMM map 24081 .quant16AsymmOperands = {}, 24082 // int -> QUANT8_SYMM map 24083 .quant8SymmOperands = {}, 24084 }, 24085 //Output(s) 24086 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24087 // int -> Dimensions map 24088 .operandDimensions = {{0, {1, 1, 4, 4}}}, 24089 // int -> FLOAT32 map 24090 .float32Operands = {}, 24091 // int -> INT32 map 24092 .int32Operands = {}, 24093 // int -> QUANT8_ASYMM map 24094 .quant8AsymmOperands = {}, 24095 // int -> QUANT16_SYMM map 24096 .quant16SymmOperands = {}, 24097 // int -> FLOAT16 map 24098 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 24099 // int -> BOOL8 map 24100 .bool8Operands = {}, 24101 // int -> QUANT8_SYMM_PER_CHANNEL map 24102 .quant8ChannelOperands = {}, 24103 // int -> QUANT16_ASYMM map 24104 .quant16AsymmOperands = {}, 24105 // int -> QUANT8_SYMM map 24106 .quant8SymmOperands = {}, 24107 } 24108 }, 24109 }, // End of an example 24110 }; 24111 return examples_dynamic_output_shape_nchw_float16_5; 24112 }; 24113 24114 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16_weight_as_input_5() { 24115 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16_weight_as_input_5 = { 24116 // Begin of an example 24117 { 24118 .operands = { 24119 //Input(s) 24120 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24121 // int -> Dimensions map 24122 .operandDimensions = {{0, {1, 1, 2, 2}}, {1, {1, 1, 1, 1}}, {2, {1}}}, 24123 // int -> FLOAT32 map 24124 .float32Operands = {}, 24125 // int -> INT32 map 24126 .int32Operands = {}, 24127 // int -> QUANT8_ASYMM map 24128 .quant8AsymmOperands = {}, 24129 // int -> QUANT16_SYMM map 24130 .quant16SymmOperands = {}, 24131 // int -> FLOAT16 map 24132 .float16Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f}}, {1, {2.0f}}, {2, {0.0f}}}, 24133 // int -> BOOL8 map 24134 .bool8Operands = {}, 24135 // int -> QUANT8_SYMM_PER_CHANNEL map 24136 .quant8ChannelOperands = {}, 24137 // int -> QUANT16_ASYMM map 24138 .quant16AsymmOperands = {}, 24139 // int -> QUANT8_SYMM map 24140 .quant8SymmOperands = {}, 24141 }, 24142 //Output(s) 24143 { // See tools/test_generator/include/TestHarness.h:MixedTyped 24144 // int -> Dimensions map 24145 .operandDimensions = {{0, {1, 1, 4, 4}}}, 24146 // int -> FLOAT32 map 24147 .float32Operands = {}, 24148 // int -> INT32 map 24149 .int32Operands = {}, 24150 // int -> QUANT8_ASYMM map 24151 .quant8AsymmOperands = {}, 24152 // int -> QUANT16_SYMM map 24153 .quant16SymmOperands = {}, 24154 // int -> FLOAT16 map 24155 .float16Operands = {{0, {2.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, 0.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}}, 24156 // int -> BOOL8 map 24157 .bool8Operands = {}, 24158 // int -> QUANT8_SYMM_PER_CHANNEL map 24159 .quant8ChannelOperands = {}, 24160 // int -> QUANT16_ASYMM map 24161 .quant16AsymmOperands = {}, 24162 // int -> QUANT8_SYMM map 24163 .quant8SymmOperands = {}, 24164 } 24165 }, 24166 }, // End of an example 24167 }; 24168 return examples_dynamic_output_shape_nchw_float16_weight_as_input_5; 24169 }; 24170 24171
