1 // clang-format off 2 // Generated file (from: topk_v2.mod.py). Do not edit 3 void CreateModel(Model *model) { 4 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 5 OperandType type1(Type::INT32, {}); 6 OperandType type2(Type::TENSOR_INT32, {2, 2}); 7 // Phase 1, operands 8 auto input = model->addOperand(&type0); 9 auto k = model->addOperand(&type1); 10 auto out_values = model->addOperand(&type0); 11 auto out_indices = model->addOperand(&type2); 12 // Phase 2, operations 13 static int32_t k_init[] = {2}; 14 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 15 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 16 // Phase 3, inputs and outputs 17 model->identifyInputsAndOutputs( 18 {input}, 19 {out_values, out_indices}); 20 assert(model->isValid()); 21 } 22 23 inline bool is_ignored(int i) { 24 static std::set<int> ignore = {}; 25 return ignore.find(i) != ignore.end(); 26 } 27 28 void CreateModel_relaxed(Model *model) { 29 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 30 OperandType type1(Type::INT32, {}); 31 OperandType type2(Type::TENSOR_INT32, {2, 2}); 32 // Phase 1, operands 33 auto input = model->addOperand(&type0); 34 auto k = model->addOperand(&type1); 35 auto out_values = model->addOperand(&type0); 36 auto out_indices = model->addOperand(&type2); 37 // Phase 2, operations 38 static int32_t k_init[] = {2}; 39 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 40 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 41 // Phase 3, inputs and outputs 42 model->identifyInputsAndOutputs( 43 {input}, 44 {out_values, out_indices}); 45 // Phase 4: set relaxed execution 46 model->relaxComputationFloat32toFloat16(true); 47 assert(model->isValid()); 48 } 49 50 inline bool is_ignored_relaxed(int i) { 51 static std::set<int> ignore = {}; 52 return ignore.find(i) != ignore.end(); 53 } 54 55 void CreateModel_float16(Model *model) { 56 OperandType type1(Type::INT32, {}); 57 OperandType type11(Type::TENSOR_FLOAT16, {2, 2}); 58 OperandType type2(Type::TENSOR_INT32, {2, 2}); 59 // Phase 1, operands 60 auto input = model->addOperand(&type11); 61 auto k = model->addOperand(&type1); 62 auto out_values = model->addOperand(&type11); 63 auto out_indices = model->addOperand(&type2); 64 // Phase 2, operations 65 static int32_t k_init[] = {2}; 66 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 67 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 68 // Phase 3, inputs and outputs 69 model->identifyInputsAndOutputs( 70 {input}, 71 {out_values, out_indices}); 72 assert(model->isValid()); 73 } 74 75 inline bool is_ignored_float16(int i) { 76 static std::set<int> ignore = {}; 77 return ignore.find(i) != ignore.end(); 78 } 79 80 void CreateModel_dynamic_output_shape(Model *model) { 81 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 82 OperandType type1(Type::INT32, {}); 83 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 84 OperandType type13(Type::TENSOR_INT32, {0, 0}); 85 // Phase 1, operands 86 auto input = model->addOperand(&type0); 87 auto k = model->addOperand(&type1); 88 auto out_values = model->addOperand(&type12); 89 auto out_indices = model->addOperand(&type13); 90 // Phase 2, operations 91 static int32_t k_init[] = {2}; 92 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 93 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 94 // Phase 3, inputs and outputs 95 model->identifyInputsAndOutputs( 96 {input}, 97 {out_values, out_indices}); 98 assert(model->isValid()); 99 } 100 101 inline bool is_ignored_dynamic_output_shape(int i) { 102 static std::set<int> ignore = {}; 103 return ignore.find(i) != ignore.end(); 104 } 105 106 void CreateModel_dynamic_output_shape_relaxed(Model *model) { 107 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 108 OperandType type1(Type::INT32, {}); 109 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 110 OperandType type13(Type::TENSOR_INT32, {0, 0}); 111 // Phase 1, operands 112 auto input = model->addOperand(&type0); 113 auto k = model->addOperand(&type1); 114 auto out_values = model->addOperand(&type12); 115 auto out_indices = model->addOperand(&type13); 116 // Phase 2, operations 117 static int32_t k_init[] = {2}; 118 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 119 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 120 // Phase 3, inputs and outputs 121 model->identifyInputsAndOutputs( 122 {input}, 123 {out_values, out_indices}); 124 // Phase 4: set relaxed execution 125 model->relaxComputationFloat32toFloat16(true); 126 assert(model->isValid()); 127 } 128 129 inline bool is_ignored_dynamic_output_shape_relaxed(int i) { 130 static std::set<int> ignore = {}; 131 return ignore.find(i) != ignore.end(); 132 } 133 134 void CreateModel_dynamic_output_shape_float16(Model *model) { 135 OperandType type1(Type::INT32, {}); 136 OperandType type11(Type::TENSOR_FLOAT16, {2, 2}); 137 OperandType type13(Type::TENSOR_INT32, {0, 0}); 138 OperandType type14(Type::TENSOR_FLOAT16, {0, 0}); 139 // Phase 1, operands 140 auto input = model->addOperand(&type11); 141 auto k = model->addOperand(&type1); 142 auto out_values = model->addOperand(&type14); 143 auto out_indices = model->addOperand(&type13); 144 // Phase 2, operations 145 static int32_t k_init[] = {2}; 146 model->setOperandValue(k, k_init, sizeof(int32_t) * 1); 147 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input, k}, {out_values, out_indices}); 148 // Phase 3, inputs and outputs 149 model->identifyInputsAndOutputs( 150 {input}, 151 {out_values, out_indices}); 152 assert(model->isValid()); 153 } 154 155 inline bool is_ignored_dynamic_output_shape_float16(int i) { 156 static std::set<int> ignore = {}; 157 return ignore.find(i) != ignore.end(); 158 } 159 160 void CreateModel_2(Model *model) { 161 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 162 OperandType type1(Type::INT32, {}); 163 OperandType type2(Type::TENSOR_INT32, {2, 2}); 164 OperandType type3(Type::TENSOR_FLOAT32, {2, 3}); 165 // Phase 1, operands 166 auto input1 = model->addOperand(&type3); 167 auto k1 = model->addOperand(&type1); 168 auto out_values1 = model->addOperand(&type0); 169 auto out_indices1 = model->addOperand(&type2); 170 // Phase 2, operations 171 static int32_t k1_init[] = {2}; 172 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 173 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 174 // Phase 3, inputs and outputs 175 model->identifyInputsAndOutputs( 176 {input1}, 177 {out_values1, out_indices1}); 178 assert(model->isValid()); 179 } 180 181 inline bool is_ignored_2(int i) { 182 static std::set<int> ignore = {}; 183 return ignore.find(i) != ignore.end(); 184 } 185 186 void CreateModel_relaxed_2(Model *model) { 187 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 188 OperandType type1(Type::INT32, {}); 189 OperandType type2(Type::TENSOR_INT32, {2, 2}); 190 OperandType type3(Type::TENSOR_FLOAT32, {2, 3}); 191 // Phase 1, operands 192 auto input1 = model->addOperand(&type3); 193 auto k1 = model->addOperand(&type1); 194 auto out_values1 = model->addOperand(&type0); 195 auto out_indices1 = model->addOperand(&type2); 196 // Phase 2, operations 197 static int32_t k1_init[] = {2}; 198 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 199 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 200 // Phase 3, inputs and outputs 201 model->identifyInputsAndOutputs( 202 {input1}, 203 {out_values1, out_indices1}); 204 // Phase 4: set relaxed execution 205 model->relaxComputationFloat32toFloat16(true); 206 assert(model->isValid()); 207 } 208 209 inline bool is_ignored_relaxed_2(int i) { 210 static std::set<int> ignore = {}; 211 return ignore.find(i) != ignore.end(); 212 } 213 214 void CreateModel_float16_2(Model *model) { 215 OperandType type1(Type::INT32, {}); 216 OperandType type11(Type::TENSOR_FLOAT16, {2, 2}); 217 OperandType type15(Type::TENSOR_FLOAT16, {2, 3}); 218 OperandType type2(Type::TENSOR_INT32, {2, 2}); 219 // Phase 1, operands 220 auto input1 = model->addOperand(&type15); 221 auto k1 = model->addOperand(&type1); 222 auto out_values1 = model->addOperand(&type11); 223 auto out_indices1 = model->addOperand(&type2); 224 // Phase 2, operations 225 static int32_t k1_init[] = {2}; 226 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 227 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 228 // Phase 3, inputs and outputs 229 model->identifyInputsAndOutputs( 230 {input1}, 231 {out_values1, out_indices1}); 232 assert(model->isValid()); 233 } 234 235 inline bool is_ignored_float16_2(int i) { 236 static std::set<int> ignore = {}; 237 return ignore.find(i) != ignore.end(); 238 } 239 240 void CreateModel_dynamic_output_shape_2(Model *model) { 241 OperandType type1(Type::INT32, {}); 242 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 243 OperandType type13(Type::TENSOR_INT32, {0, 0}); 244 OperandType type3(Type::TENSOR_FLOAT32, {2, 3}); 245 // Phase 1, operands 246 auto input1 = model->addOperand(&type3); 247 auto k1 = model->addOperand(&type1); 248 auto out_values1 = model->addOperand(&type12); 249 auto out_indices1 = model->addOperand(&type13); 250 // Phase 2, operations 251 static int32_t k1_init[] = {2}; 252 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 253 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 254 // Phase 3, inputs and outputs 255 model->identifyInputsAndOutputs( 256 {input1}, 257 {out_values1, out_indices1}); 258 assert(model->isValid()); 259 } 260 261 inline bool is_ignored_dynamic_output_shape_2(int i) { 262 static std::set<int> ignore = {}; 263 return ignore.find(i) != ignore.end(); 264 } 265 266 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) { 267 OperandType type1(Type::INT32, {}); 268 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 269 OperandType type13(Type::TENSOR_INT32, {0, 0}); 270 OperandType type3(Type::TENSOR_FLOAT32, {2, 3}); 271 // Phase 1, operands 272 auto input1 = model->addOperand(&type3); 273 auto k1 = model->addOperand(&type1); 274 auto out_values1 = model->addOperand(&type12); 275 auto out_indices1 = model->addOperand(&type13); 276 // Phase 2, operations 277 static int32_t k1_init[] = {2}; 278 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 279 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 280 // Phase 3, inputs and outputs 281 model->identifyInputsAndOutputs( 282 {input1}, 283 {out_values1, out_indices1}); 284 // Phase 4: set relaxed execution 285 model->relaxComputationFloat32toFloat16(true); 286 assert(model->isValid()); 287 } 288 289 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) { 290 static std::set<int> ignore = {}; 291 return ignore.find(i) != ignore.end(); 292 } 293 294 void CreateModel_dynamic_output_shape_float16_2(Model *model) { 295 OperandType type1(Type::INT32, {}); 296 OperandType type13(Type::TENSOR_INT32, {0, 0}); 297 OperandType type14(Type::TENSOR_FLOAT16, {0, 0}); 298 OperandType type15(Type::TENSOR_FLOAT16, {2, 3}); 299 // Phase 1, operands 300 auto input1 = model->addOperand(&type15); 301 auto k1 = model->addOperand(&type1); 302 auto out_values1 = model->addOperand(&type14); 303 auto out_indices1 = model->addOperand(&type13); 304 // Phase 2, operations 305 static int32_t k1_init[] = {2}; 306 model->setOperandValue(k1, k1_init, sizeof(int32_t) * 1); 307 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input1, k1}, {out_values1, out_indices1}); 308 // Phase 3, inputs and outputs 309 model->identifyInputsAndOutputs( 310 {input1}, 311 {out_values1, out_indices1}); 312 assert(model->isValid()); 313 } 314 315 inline bool is_ignored_dynamic_output_shape_float16_2(int i) { 316 static std::set<int> ignore = {}; 317 return ignore.find(i) != ignore.end(); 318 } 319 320 void CreateModel_3(Model *model) { 321 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 322 OperandType type1(Type::INT32, {}); 323 OperandType type2(Type::TENSOR_INT32, {2, 2}); 324 OperandType type4(Type::TENSOR_FLOAT32, {2, 4}); 325 // Phase 1, operands 326 auto input2 = model->addOperand(&type4); 327 auto k2 = model->addOperand(&type1); 328 auto out_values2 = model->addOperand(&type0); 329 auto out_indices2 = model->addOperand(&type2); 330 // Phase 2, operations 331 static int32_t k2_init[] = {2}; 332 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 333 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 334 // Phase 3, inputs and outputs 335 model->identifyInputsAndOutputs( 336 {input2}, 337 {out_values2, out_indices2}); 338 assert(model->isValid()); 339 } 340 341 inline bool is_ignored_3(int i) { 342 static std::set<int> ignore = {}; 343 return ignore.find(i) != ignore.end(); 344 } 345 346 void CreateModel_relaxed_3(Model *model) { 347 OperandType type0(Type::TENSOR_FLOAT32, {2, 2}); 348 OperandType type1(Type::INT32, {}); 349 OperandType type2(Type::TENSOR_INT32, {2, 2}); 350 OperandType type4(Type::TENSOR_FLOAT32, {2, 4}); 351 // Phase 1, operands 352 auto input2 = model->addOperand(&type4); 353 auto k2 = model->addOperand(&type1); 354 auto out_values2 = model->addOperand(&type0); 355 auto out_indices2 = model->addOperand(&type2); 356 // Phase 2, operations 357 static int32_t k2_init[] = {2}; 358 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 359 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 360 // Phase 3, inputs and outputs 361 model->identifyInputsAndOutputs( 362 {input2}, 363 {out_values2, out_indices2}); 364 // Phase 4: set relaxed execution 365 model->relaxComputationFloat32toFloat16(true); 366 assert(model->isValid()); 367 } 368 369 inline bool is_ignored_relaxed_3(int i) { 370 static std::set<int> ignore = {}; 371 return ignore.find(i) != ignore.end(); 372 } 373 374 void CreateModel_float16_3(Model *model) { 375 OperandType type1(Type::INT32, {}); 376 OperandType type11(Type::TENSOR_FLOAT16, {2, 2}); 377 OperandType type16(Type::TENSOR_FLOAT16, {2, 4}); 378 OperandType type2(Type::TENSOR_INT32, {2, 2}); 379 // Phase 1, operands 380 auto input2 = model->addOperand(&type16); 381 auto k2 = model->addOperand(&type1); 382 auto out_values2 = model->addOperand(&type11); 383 auto out_indices2 = model->addOperand(&type2); 384 // Phase 2, operations 385 static int32_t k2_init[] = {2}; 386 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 387 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 388 // Phase 3, inputs and outputs 389 model->identifyInputsAndOutputs( 390 {input2}, 391 {out_values2, out_indices2}); 392 assert(model->isValid()); 393 } 394 395 inline bool is_ignored_float16_3(int i) { 396 static std::set<int> ignore = {}; 397 return ignore.find(i) != ignore.end(); 398 } 399 400 void CreateModel_dynamic_output_shape_3(Model *model) { 401 OperandType type1(Type::INT32, {}); 402 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 403 OperandType type13(Type::TENSOR_INT32, {0, 0}); 404 OperandType type4(Type::TENSOR_FLOAT32, {2, 4}); 405 // Phase 1, operands 406 auto input2 = model->addOperand(&type4); 407 auto k2 = model->addOperand(&type1); 408 auto out_values2 = model->addOperand(&type12); 409 auto out_indices2 = model->addOperand(&type13); 410 // Phase 2, operations 411 static int32_t k2_init[] = {2}; 412 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 413 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 414 // Phase 3, inputs and outputs 415 model->identifyInputsAndOutputs( 416 {input2}, 417 {out_values2, out_indices2}); 418 assert(model->isValid()); 419 } 420 421 inline bool is_ignored_dynamic_output_shape_3(int i) { 422 static std::set<int> ignore = {}; 423 return ignore.find(i) != ignore.end(); 424 } 425 426 void CreateModel_dynamic_output_shape_relaxed_3(Model *model) { 427 OperandType type1(Type::INT32, {}); 428 OperandType type12(Type::TENSOR_FLOAT32, {0, 0}); 429 OperandType type13(Type::TENSOR_INT32, {0, 0}); 430 OperandType type4(Type::TENSOR_FLOAT32, {2, 4}); 431 // Phase 1, operands 432 auto input2 = model->addOperand(&type4); 433 auto k2 = model->addOperand(&type1); 434 auto out_values2 = model->addOperand(&type12); 435 auto out_indices2 = model->addOperand(&type13); 436 // Phase 2, operations 437 static int32_t k2_init[] = {2}; 438 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 439 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 440 // Phase 3, inputs and outputs 441 model->identifyInputsAndOutputs( 442 {input2}, 443 {out_values2, out_indices2}); 444 // Phase 4: set relaxed execution 445 model->relaxComputationFloat32toFloat16(true); 446 assert(model->isValid()); 447 } 448 449 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) { 450 static std::set<int> ignore = {}; 451 return ignore.find(i) != ignore.end(); 452 } 453 454 void CreateModel_dynamic_output_shape_float16_3(Model *model) { 455 OperandType type1(Type::INT32, {}); 456 OperandType type13(Type::TENSOR_INT32, {0, 0}); 457 OperandType type14(Type::TENSOR_FLOAT16, {0, 0}); 458 OperandType type16(Type::TENSOR_FLOAT16, {2, 4}); 459 // Phase 1, operands 460 auto input2 = model->addOperand(&type16); 461 auto k2 = model->addOperand(&type1); 462 auto out_values2 = model->addOperand(&type14); 463 auto out_indices2 = model->addOperand(&type13); 464 // Phase 2, operations 465 static int32_t k2_init[] = {2}; 466 model->setOperandValue(k2, k2_init, sizeof(int32_t) * 1); 467 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input2, k2}, {out_values2, out_indices2}); 468 // Phase 3, inputs and outputs 469 model->identifyInputsAndOutputs( 470 {input2}, 471 {out_values2, out_indices2}); 472 assert(model->isValid()); 473 } 474 475 inline bool is_ignored_dynamic_output_shape_float16_3(int i) { 476 static std::set<int> ignore = {}; 477 return ignore.find(i) != ignore.end(); 478 } 479 480 void CreateModel_4(Model *model) { 481 OperandType type1(Type::INT32, {}); 482 OperandType type5(Type::TENSOR_FLOAT32, {8}); 483 OperandType type6(Type::TENSOR_FLOAT32, {2}); 484 OperandType type7(Type::TENSOR_INT32, {2}); 485 // Phase 1, operands 486 auto input3 = model->addOperand(&type5); 487 auto k3 = model->addOperand(&type1); 488 auto out_values3 = model->addOperand(&type6); 489 auto out_indices3 = model->addOperand(&type7); 490 // Phase 2, operations 491 static int32_t k3_init[] = {2}; 492 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 493 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 494 // Phase 3, inputs and outputs 495 model->identifyInputsAndOutputs( 496 {input3}, 497 {out_values3, out_indices3}); 498 assert(model->isValid()); 499 } 500 501 inline bool is_ignored_4(int i) { 502 static std::set<int> ignore = {}; 503 return ignore.find(i) != ignore.end(); 504 } 505 506 void CreateModel_relaxed_4(Model *model) { 507 OperandType type1(Type::INT32, {}); 508 OperandType type5(Type::TENSOR_FLOAT32, {8}); 509 OperandType type6(Type::TENSOR_FLOAT32, {2}); 510 OperandType type7(Type::TENSOR_INT32, {2}); 511 // Phase 1, operands 512 auto input3 = model->addOperand(&type5); 513 auto k3 = model->addOperand(&type1); 514 auto out_values3 = model->addOperand(&type6); 515 auto out_indices3 = model->addOperand(&type7); 516 // Phase 2, operations 517 static int32_t k3_init[] = {2}; 518 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 519 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 520 // Phase 3, inputs and outputs 521 model->identifyInputsAndOutputs( 522 {input3}, 523 {out_values3, out_indices3}); 524 // Phase 4: set relaxed execution 525 model->relaxComputationFloat32toFloat16(true); 526 assert(model->isValid()); 527 } 528 529 inline bool is_ignored_relaxed_4(int i) { 530 static std::set<int> ignore = {}; 531 return ignore.find(i) != ignore.end(); 532 } 533 534 void CreateModel_float16_4(Model *model) { 535 OperandType type1(Type::INT32, {}); 536 OperandType type17(Type::TENSOR_FLOAT16, {8}); 537 OperandType type18(Type::TENSOR_FLOAT16, {2}); 538 OperandType type7(Type::TENSOR_INT32, {2}); 539 // Phase 1, operands 540 auto input3 = model->addOperand(&type17); 541 auto k3 = model->addOperand(&type1); 542 auto out_values3 = model->addOperand(&type18); 543 auto out_indices3 = model->addOperand(&type7); 544 // Phase 2, operations 545 static int32_t k3_init[] = {2}; 546 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 547 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 548 // Phase 3, inputs and outputs 549 model->identifyInputsAndOutputs( 550 {input3}, 551 {out_values3, out_indices3}); 552 assert(model->isValid()); 553 } 554 555 inline bool is_ignored_float16_4(int i) { 556 static std::set<int> ignore = {}; 557 return ignore.find(i) != ignore.end(); 558 } 559 560 void CreateModel_dynamic_output_shape_4(Model *model) { 561 OperandType type1(Type::INT32, {}); 562 OperandType type19(Type::TENSOR_FLOAT32, {0}); 563 OperandType type20(Type::TENSOR_INT32, {0}); 564 OperandType type5(Type::TENSOR_FLOAT32, {8}); 565 // Phase 1, operands 566 auto input3 = model->addOperand(&type5); 567 auto k3 = model->addOperand(&type1); 568 auto out_values3 = model->addOperand(&type19); 569 auto out_indices3 = model->addOperand(&type20); 570 // Phase 2, operations 571 static int32_t k3_init[] = {2}; 572 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 573 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 574 // Phase 3, inputs and outputs 575 model->identifyInputsAndOutputs( 576 {input3}, 577 {out_values3, out_indices3}); 578 assert(model->isValid()); 579 } 580 581 inline bool is_ignored_dynamic_output_shape_4(int i) { 582 static std::set<int> ignore = {}; 583 return ignore.find(i) != ignore.end(); 584 } 585 586 void CreateModel_dynamic_output_shape_relaxed_4(Model *model) { 587 OperandType type1(Type::INT32, {}); 588 OperandType type19(Type::TENSOR_FLOAT32, {0}); 589 OperandType type20(Type::TENSOR_INT32, {0}); 590 OperandType type5(Type::TENSOR_FLOAT32, {8}); 591 // Phase 1, operands 592 auto input3 = model->addOperand(&type5); 593 auto k3 = model->addOperand(&type1); 594 auto out_values3 = model->addOperand(&type19); 595 auto out_indices3 = model->addOperand(&type20); 596 // Phase 2, operations 597 static int32_t k3_init[] = {2}; 598 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 599 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 600 // Phase 3, inputs and outputs 601 model->identifyInputsAndOutputs( 602 {input3}, 603 {out_values3, out_indices3}); 604 // Phase 4: set relaxed execution 605 model->relaxComputationFloat32toFloat16(true); 606 assert(model->isValid()); 607 } 608 609 inline bool is_ignored_dynamic_output_shape_relaxed_4(int i) { 610 static std::set<int> ignore = {}; 611 return ignore.find(i) != ignore.end(); 612 } 613 614 void CreateModel_dynamic_output_shape_float16_4(Model *model) { 615 OperandType type1(Type::INT32, {}); 616 OperandType type17(Type::TENSOR_FLOAT16, {8}); 617 OperandType type20(Type::TENSOR_INT32, {0}); 618 OperandType type21(Type::TENSOR_FLOAT16, {0}); 619 // Phase 1, operands 620 auto input3 = model->addOperand(&type17); 621 auto k3 = model->addOperand(&type1); 622 auto out_values3 = model->addOperand(&type21); 623 auto out_indices3 = model->addOperand(&type20); 624 // Phase 2, operations 625 static int32_t k3_init[] = {2}; 626 model->setOperandValue(k3, k3_init, sizeof(int32_t) * 1); 627 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input3, k3}, {out_values3, out_indices3}); 628 // Phase 3, inputs and outputs 629 model->identifyInputsAndOutputs( 630 {input3}, 631 {out_values3, out_indices3}); 632 assert(model->isValid()); 633 } 634 635 inline bool is_ignored_dynamic_output_shape_float16_4(int i) { 636 static std::set<int> ignore = {}; 637 return ignore.find(i) != ignore.end(); 638 } 639 640 void CreateModel_5(Model *model) { 641 OperandType type1(Type::INT32, {}); 642 OperandType type2(Type::TENSOR_INT32, {2, 2}); 643 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 644 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 2.0f, 128); 645 // Phase 1, operands 646 auto input4 = model->addOperand(&type8); 647 auto k4 = model->addOperand(&type1); 648 auto out_values4 = model->addOperand(&type9); 649 auto out_indices4 = model->addOperand(&type2); 650 // Phase 2, operations 651 static int32_t k4_init[] = {2}; 652 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 653 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 654 // Phase 3, inputs and outputs 655 model->identifyInputsAndOutputs( 656 {input4}, 657 {out_values4, out_indices4}); 658 assert(model->isValid()); 659 } 660 661 inline bool is_ignored_5(int i) { 662 static std::set<int> ignore = {}; 663 return ignore.find(i) != ignore.end(); 664 } 665 666 void CreateModel_relaxed_5(Model *model) { 667 OperandType type1(Type::INT32, {}); 668 OperandType type2(Type::TENSOR_INT32, {2, 2}); 669 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 670 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 2.0f, 128); 671 // Phase 1, operands 672 auto input4 = model->addOperand(&type8); 673 auto k4 = model->addOperand(&type1); 674 auto out_values4 = model->addOperand(&type9); 675 auto out_indices4 = model->addOperand(&type2); 676 // Phase 2, operations 677 static int32_t k4_init[] = {2}; 678 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 679 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 680 // Phase 3, inputs and outputs 681 model->identifyInputsAndOutputs( 682 {input4}, 683 {out_values4, out_indices4}); 684 // Phase 4: set relaxed execution 685 model->relaxComputationFloat32toFloat16(true); 686 assert(model->isValid()); 687 } 688 689 inline bool is_ignored_relaxed_5(int i) { 690 static std::set<int> ignore = {}; 691 return ignore.find(i) != ignore.end(); 692 } 693 694 void CreateModel_float16_5(Model *model) { 695 OperandType type1(Type::INT32, {}); 696 OperandType type2(Type::TENSOR_INT32, {2, 2}); 697 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 698 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 2.0f, 128); 699 // Phase 1, operands 700 auto input4 = model->addOperand(&type8); 701 auto k4 = model->addOperand(&type1); 702 auto out_values4 = model->addOperand(&type9); 703 auto out_indices4 = model->addOperand(&type2); 704 // Phase 2, operations 705 static int32_t k4_init[] = {2}; 706 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 707 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 708 // Phase 3, inputs and outputs 709 model->identifyInputsAndOutputs( 710 {input4}, 711 {out_values4, out_indices4}); 712 assert(model->isValid()); 713 } 714 715 inline bool is_ignored_float16_5(int i) { 716 static std::set<int> ignore = {}; 717 return ignore.find(i) != ignore.end(); 718 } 719 720 void CreateModel_dynamic_output_shape_5(Model *model) { 721 OperandType type1(Type::INT32, {}); 722 OperandType type13(Type::TENSOR_INT32, {0, 0}); 723 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 2.0f, 128); 724 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 725 // Phase 1, operands 726 auto input4 = model->addOperand(&type8); 727 auto k4 = model->addOperand(&type1); 728 auto out_values4 = model->addOperand(&type22); 729 auto out_indices4 = model->addOperand(&type13); 730 // Phase 2, operations 731 static int32_t k4_init[] = {2}; 732 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 733 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 734 // Phase 3, inputs and outputs 735 model->identifyInputsAndOutputs( 736 {input4}, 737 {out_values4, out_indices4}); 738 assert(model->isValid()); 739 } 740 741 inline bool is_ignored_dynamic_output_shape_5(int i) { 742 static std::set<int> ignore = {}; 743 return ignore.find(i) != ignore.end(); 744 } 745 746 void CreateModel_dynamic_output_shape_relaxed_5(Model *model) { 747 OperandType type1(Type::INT32, {}); 748 OperandType type13(Type::TENSOR_INT32, {0, 0}); 749 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 2.0f, 128); 750 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 751 // Phase 1, operands 752 auto input4 = model->addOperand(&type8); 753 auto k4 = model->addOperand(&type1); 754 auto out_values4 = model->addOperand(&type22); 755 auto out_indices4 = model->addOperand(&type13); 756 // Phase 2, operations 757 static int32_t k4_init[] = {2}; 758 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 759 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 760 // Phase 3, inputs and outputs 761 model->identifyInputsAndOutputs( 762 {input4}, 763 {out_values4, out_indices4}); 764 // Phase 4: set relaxed execution 765 model->relaxComputationFloat32toFloat16(true); 766 assert(model->isValid()); 767 } 768 769 inline bool is_ignored_dynamic_output_shape_relaxed_5(int i) { 770 static std::set<int> ignore = {}; 771 return ignore.find(i) != ignore.end(); 772 } 773 774 void CreateModel_dynamic_output_shape_float16_5(Model *model) { 775 OperandType type1(Type::INT32, {}); 776 OperandType type13(Type::TENSOR_INT32, {0, 0}); 777 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 2.0f, 128); 778 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 2.0f, 128); 779 // Phase 1, operands 780 auto input4 = model->addOperand(&type8); 781 auto k4 = model->addOperand(&type1); 782 auto out_values4 = model->addOperand(&type22); 783 auto out_indices4 = model->addOperand(&type13); 784 // Phase 2, operations 785 static int32_t k4_init[] = {2}; 786 model->setOperandValue(k4, k4_init, sizeof(int32_t) * 1); 787 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input4, k4}, {out_values4, out_indices4}); 788 // Phase 3, inputs and outputs 789 model->identifyInputsAndOutputs( 790 {input4}, 791 {out_values4, out_indices4}); 792 assert(model->isValid()); 793 } 794 795 inline bool is_ignored_dynamic_output_shape_float16_5(int i) { 796 static std::set<int> ignore = {}; 797 return ignore.find(i) != ignore.end(); 798 } 799 800 void CreateModel_6(Model *model) { 801 OperandType type1(Type::INT32, {}); 802 OperandType type10(Type::TENSOR_INT32, {2, 3}); 803 OperandType type2(Type::TENSOR_INT32, {2, 2}); 804 // Phase 1, operands 805 auto input5 = model->addOperand(&type10); 806 auto k5 = model->addOperand(&type1); 807 auto out_values5 = model->addOperand(&type2); 808 auto out_indices5 = model->addOperand(&type2); 809 // Phase 2, operations 810 static int32_t k5_init[] = {2}; 811 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 812 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 813 // Phase 3, inputs and outputs 814 model->identifyInputsAndOutputs( 815 {input5}, 816 {out_values5, out_indices5}); 817 assert(model->isValid()); 818 } 819 820 inline bool is_ignored_6(int i) { 821 static std::set<int> ignore = {}; 822 return ignore.find(i) != ignore.end(); 823 } 824 825 void CreateModel_relaxed_6(Model *model) { 826 OperandType type1(Type::INT32, {}); 827 OperandType type10(Type::TENSOR_INT32, {2, 3}); 828 OperandType type2(Type::TENSOR_INT32, {2, 2}); 829 // Phase 1, operands 830 auto input5 = model->addOperand(&type10); 831 auto k5 = model->addOperand(&type1); 832 auto out_values5 = model->addOperand(&type2); 833 auto out_indices5 = model->addOperand(&type2); 834 // Phase 2, operations 835 static int32_t k5_init[] = {2}; 836 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 837 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 838 // Phase 3, inputs and outputs 839 model->identifyInputsAndOutputs( 840 {input5}, 841 {out_values5, out_indices5}); 842 // Phase 4: set relaxed execution 843 model->relaxComputationFloat32toFloat16(true); 844 assert(model->isValid()); 845 } 846 847 inline bool is_ignored_relaxed_6(int i) { 848 static std::set<int> ignore = {}; 849 return ignore.find(i) != ignore.end(); 850 } 851 852 void CreateModel_float16_6(Model *model) { 853 OperandType type1(Type::INT32, {}); 854 OperandType type10(Type::TENSOR_INT32, {2, 3}); 855 OperandType type2(Type::TENSOR_INT32, {2, 2}); 856 // Phase 1, operands 857 auto input5 = model->addOperand(&type10); 858 auto k5 = model->addOperand(&type1); 859 auto out_values5 = model->addOperand(&type2); 860 auto out_indices5 = model->addOperand(&type2); 861 // Phase 2, operations 862 static int32_t k5_init[] = {2}; 863 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 864 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 865 // Phase 3, inputs and outputs 866 model->identifyInputsAndOutputs( 867 {input5}, 868 {out_values5, out_indices5}); 869 assert(model->isValid()); 870 } 871 872 inline bool is_ignored_float16_6(int i) { 873 static std::set<int> ignore = {}; 874 return ignore.find(i) != ignore.end(); 875 } 876 877 void CreateModel_dynamic_output_shape_6(Model *model) { 878 OperandType type1(Type::INT32, {}); 879 OperandType type10(Type::TENSOR_INT32, {2, 3}); 880 OperandType type13(Type::TENSOR_INT32, {0, 0}); 881 // Phase 1, operands 882 auto input5 = model->addOperand(&type10); 883 auto k5 = model->addOperand(&type1); 884 auto out_values5 = model->addOperand(&type13); 885 auto out_indices5 = model->addOperand(&type13); 886 // Phase 2, operations 887 static int32_t k5_init[] = {2}; 888 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 889 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 890 // Phase 3, inputs and outputs 891 model->identifyInputsAndOutputs( 892 {input5}, 893 {out_values5, out_indices5}); 894 assert(model->isValid()); 895 } 896 897 inline bool is_ignored_dynamic_output_shape_6(int i) { 898 static std::set<int> ignore = {}; 899 return ignore.find(i) != ignore.end(); 900 } 901 902 void CreateModel_dynamic_output_shape_relaxed_6(Model *model) { 903 OperandType type1(Type::INT32, {}); 904 OperandType type10(Type::TENSOR_INT32, {2, 3}); 905 OperandType type13(Type::TENSOR_INT32, {0, 0}); 906 // Phase 1, operands 907 auto input5 = model->addOperand(&type10); 908 auto k5 = model->addOperand(&type1); 909 auto out_values5 = model->addOperand(&type13); 910 auto out_indices5 = model->addOperand(&type13); 911 // Phase 2, operations 912 static int32_t k5_init[] = {2}; 913 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 914 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 915 // Phase 3, inputs and outputs 916 model->identifyInputsAndOutputs( 917 {input5}, 918 {out_values5, out_indices5}); 919 // Phase 4: set relaxed execution 920 model->relaxComputationFloat32toFloat16(true); 921 assert(model->isValid()); 922 } 923 924 inline bool is_ignored_dynamic_output_shape_relaxed_6(int i) { 925 static std::set<int> ignore = {}; 926 return ignore.find(i) != ignore.end(); 927 } 928 929 void CreateModel_dynamic_output_shape_float16_6(Model *model) { 930 OperandType type1(Type::INT32, {}); 931 OperandType type10(Type::TENSOR_INT32, {2, 3}); 932 OperandType type13(Type::TENSOR_INT32, {0, 0}); 933 // Phase 1, operands 934 auto input5 = model->addOperand(&type10); 935 auto k5 = model->addOperand(&type1); 936 auto out_values5 = model->addOperand(&type13); 937 auto out_indices5 = model->addOperand(&type13); 938 // Phase 2, operations 939 static int32_t k5_init[] = {2}; 940 model->setOperandValue(k5, k5_init, sizeof(int32_t) * 1); 941 model->addOperation(ANEURALNETWORKS_TOPK_V2, {input5, k5}, {out_values5, out_indices5}); 942 // Phase 3, inputs and outputs 943 model->identifyInputsAndOutputs( 944 {input5}, 945 {out_values5, out_indices5}); 946 assert(model->isValid()); 947 } 948 949 inline bool is_ignored_dynamic_output_shape_float16_6(int i) { 950 static std::set<int> ignore = {}; 951 return ignore.find(i) != ignore.end(); 952 } 953 954
