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