1 // clang-format off 2 // Generated file (from: detection_postprocess.mod.py). Do not edit 3 void CreateModel_regular(Model *model) { 4 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 5 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 6 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 7 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 8 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 9 OperandType type5(Type::TENSOR_INT32, {1, 3}); 10 OperandType type6(Type::TENSOR_INT32, {1}); 11 OperandType type7(Type::FLOAT32, {}); 12 OperandType type8(Type::BOOL, {}); 13 OperandType type9(Type::INT32, {}); 14 // Phase 1, operands 15 auto scores = model->addOperand(&type0); 16 auto roi = model->addOperand(&type1); 17 auto anchors = model->addOperand(&type2); 18 auto param = model->addOperand(&type7); 19 auto param1 = model->addOperand(&type7); 20 auto param2 = model->addOperand(&type7); 21 auto param3 = model->addOperand(&type7); 22 auto param4 = model->addOperand(&type8); 23 auto param5 = model->addOperand(&type9); 24 auto param6 = model->addOperand(&type9); 25 auto param7 = model->addOperand(&type9); 26 auto param8 = model->addOperand(&type7); 27 auto param9 = model->addOperand(&type7); 28 auto param10 = model->addOperand(&type8); 29 auto scoresOut = model->addOperand(&type3); 30 auto roiOut = model->addOperand(&type4); 31 auto classesOut = model->addOperand(&type5); 32 auto detectionOut = model->addOperand(&type6); 33 // Phase 2, operations 34 static float param_init[] = {10.0f}; 35 model->setOperandValue(param, param_init, sizeof(float) * 1); 36 static float param1_init[] = {10.0f}; 37 model->setOperandValue(param1, param1_init, sizeof(float) * 1); 38 static float param2_init[] = {5.0f}; 39 model->setOperandValue(param2, param2_init, sizeof(float) * 1); 40 static float param3_init[] = {5.0f}; 41 model->setOperandValue(param3, param3_init, sizeof(float) * 1); 42 static bool8 param4_init[] = {true}; 43 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 44 static int32_t param5_init[] = {3}; 45 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 46 static int32_t param6_init[] = {1}; 47 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 48 static int32_t param7_init[] = {1}; 49 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 50 static float param8_init[] = {0.0f}; 51 model->setOperandValue(param8, param8_init, sizeof(float) * 1); 52 static float param9_init[] = {0.5f}; 53 model->setOperandValue(param9, param9_init, sizeof(float) * 1); 54 static bool8 param10_init[] = {false}; 55 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 56 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 57 // Phase 3, inputs and outputs 58 model->identifyInputsAndOutputs( 59 {scores, roi, anchors}, 60 {scoresOut, roiOut, classesOut, detectionOut}); 61 assert(model->isValid()); 62 } 63 64 inline bool is_ignored_regular(int i) { 65 static std::set<int> ignore = {}; 66 return ignore.find(i) != ignore.end(); 67 } 68 69 void CreateModel_regular_relaxed(Model *model) { 70 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 71 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 72 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 73 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 74 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 75 OperandType type5(Type::TENSOR_INT32, {1, 3}); 76 OperandType type6(Type::TENSOR_INT32, {1}); 77 OperandType type7(Type::FLOAT32, {}); 78 OperandType type8(Type::BOOL, {}); 79 OperandType type9(Type::INT32, {}); 80 // Phase 1, operands 81 auto scores = model->addOperand(&type0); 82 auto roi = model->addOperand(&type1); 83 auto anchors = model->addOperand(&type2); 84 auto param = model->addOperand(&type7); 85 auto param1 = model->addOperand(&type7); 86 auto param2 = model->addOperand(&type7); 87 auto param3 = model->addOperand(&type7); 88 auto param4 = model->addOperand(&type8); 89 auto param5 = model->addOperand(&type9); 90 auto param6 = model->addOperand(&type9); 91 auto param7 = model->addOperand(&type9); 92 auto param8 = model->addOperand(&type7); 93 auto param9 = model->addOperand(&type7); 94 auto param10 = model->addOperand(&type8); 95 auto scoresOut = model->addOperand(&type3); 96 auto roiOut = model->addOperand(&type4); 97 auto classesOut = model->addOperand(&type5); 98 auto detectionOut = model->addOperand(&type6); 99 // Phase 2, operations 100 static float param_init[] = {10.0f}; 101 model->setOperandValue(param, param_init, sizeof(float) * 1); 102 static float param1_init[] = {10.0f}; 103 model->setOperandValue(param1, param1_init, sizeof(float) * 1); 104 static float param2_init[] = {5.0f}; 105 model->setOperandValue(param2, param2_init, sizeof(float) * 1); 106 static float param3_init[] = {5.0f}; 107 model->setOperandValue(param3, param3_init, sizeof(float) * 1); 108 static bool8 param4_init[] = {true}; 109 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 110 static int32_t param5_init[] = {3}; 111 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 112 static int32_t param6_init[] = {1}; 113 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 114 static int32_t param7_init[] = {1}; 115 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 116 static float param8_init[] = {0.0f}; 117 model->setOperandValue(param8, param8_init, sizeof(float) * 1); 118 static float param9_init[] = {0.5f}; 119 model->setOperandValue(param9, param9_init, sizeof(float) * 1); 120 static bool8 param10_init[] = {false}; 121 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 122 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 123 // Phase 3, inputs and outputs 124 model->identifyInputsAndOutputs( 125 {scores, roi, anchors}, 126 {scoresOut, roiOut, classesOut, detectionOut}); 127 // Phase 4: set relaxed execution 128 model->relaxComputationFloat32toFloat16(true); 129 assert(model->isValid()); 130 } 131 132 inline bool is_ignored_regular_relaxed(int i) { 133 static std::set<int> ignore = {}; 134 return ignore.find(i) != ignore.end(); 135 } 136 137 void CreateModel_regular_float16(Model *model) { 138 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 139 OperandType type12(Type::FLOAT16, {}); 140 OperandType type13(Type::TENSOR_FLOAT16, {1, 6, 4}); 141 OperandType type14(Type::TENSOR_FLOAT16, {1, 3, 4}); 142 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 143 OperandType type16(Type::TENSOR_FLOAT16, {1, 3}); 144 OperandType type5(Type::TENSOR_INT32, {1, 3}); 145 OperandType type6(Type::TENSOR_INT32, {1}); 146 OperandType type8(Type::BOOL, {}); 147 OperandType type9(Type::INT32, {}); 148 // Phase 1, operands 149 auto scores = model->addOperand(&type15); 150 auto roi = model->addOperand(&type13); 151 auto anchors = model->addOperand(&type11); 152 auto param = model->addOperand(&type12); 153 auto param1 = model->addOperand(&type12); 154 auto param2 = model->addOperand(&type12); 155 auto param3 = model->addOperand(&type12); 156 auto param4 = model->addOperand(&type8); 157 auto param5 = model->addOperand(&type9); 158 auto param6 = model->addOperand(&type9); 159 auto param7 = model->addOperand(&type9); 160 auto param8 = model->addOperand(&type12); 161 auto param9 = model->addOperand(&type12); 162 auto param10 = model->addOperand(&type8); 163 auto scoresOut = model->addOperand(&type16); 164 auto roiOut = model->addOperand(&type14); 165 auto classesOut = model->addOperand(&type5); 166 auto detectionOut = model->addOperand(&type6); 167 // Phase 2, operations 168 static _Float16 param_init[] = {10.0f}; 169 model->setOperandValue(param, param_init, sizeof(_Float16) * 1); 170 static _Float16 param1_init[] = {10.0f}; 171 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1); 172 static _Float16 param2_init[] = {5.0f}; 173 model->setOperandValue(param2, param2_init, sizeof(_Float16) * 1); 174 static _Float16 param3_init[] = {5.0f}; 175 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1); 176 static bool8 param4_init[] = {true}; 177 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 178 static int32_t param5_init[] = {3}; 179 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 180 static int32_t param6_init[] = {1}; 181 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 182 static int32_t param7_init[] = {1}; 183 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 184 static _Float16 param8_init[] = {0.0f}; 185 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1); 186 static _Float16 param9_init[] = {0.5f}; 187 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1); 188 static bool8 param10_init[] = {false}; 189 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 190 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 191 // Phase 3, inputs and outputs 192 model->identifyInputsAndOutputs( 193 {scores, roi, anchors}, 194 {scoresOut, roiOut, classesOut, detectionOut}); 195 assert(model->isValid()); 196 } 197 198 inline bool is_ignored_regular_float16(int i) { 199 static std::set<int> ignore = {}; 200 return ignore.find(i) != ignore.end(); 201 } 202 203 void CreateModel_regular_dynamic_output_shape(Model *model) { 204 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 205 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 206 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 207 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 208 OperandType type19(Type::TENSOR_INT32, {0, 0}); 209 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 210 OperandType type20(Type::TENSOR_INT32, {0}); 211 OperandType type7(Type::FLOAT32, {}); 212 OperandType type8(Type::BOOL, {}); 213 OperandType type9(Type::INT32, {}); 214 // Phase 1, operands 215 auto scores = model->addOperand(&type0); 216 auto roi = model->addOperand(&type1); 217 auto anchors = model->addOperand(&type2); 218 auto param = model->addOperand(&type7); 219 auto param1 = model->addOperand(&type7); 220 auto param2 = model->addOperand(&type7); 221 auto param3 = model->addOperand(&type7); 222 auto param4 = model->addOperand(&type8); 223 auto param5 = model->addOperand(&type9); 224 auto param6 = model->addOperand(&type9); 225 auto param7 = model->addOperand(&type9); 226 auto param8 = model->addOperand(&type7); 227 auto param9 = model->addOperand(&type7); 228 auto param10 = model->addOperand(&type8); 229 auto scoresOut = model->addOperand(&type17); 230 auto roiOut = model->addOperand(&type18); 231 auto classesOut = model->addOperand(&type19); 232 auto detectionOut = model->addOperand(&type20); 233 // Phase 2, operations 234 static float param_init[] = {10.0f}; 235 model->setOperandValue(param, param_init, sizeof(float) * 1); 236 static float param1_init[] = {10.0f}; 237 model->setOperandValue(param1, param1_init, sizeof(float) * 1); 238 static float param2_init[] = {5.0f}; 239 model->setOperandValue(param2, param2_init, sizeof(float) * 1); 240 static float param3_init[] = {5.0f}; 241 model->setOperandValue(param3, param3_init, sizeof(float) * 1); 242 static bool8 param4_init[] = {true}; 243 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 244 static int32_t param5_init[] = {3}; 245 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 246 static int32_t param6_init[] = {1}; 247 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 248 static int32_t param7_init[] = {1}; 249 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 250 static float param8_init[] = {0.0f}; 251 model->setOperandValue(param8, param8_init, sizeof(float) * 1); 252 static float param9_init[] = {0.5f}; 253 model->setOperandValue(param9, param9_init, sizeof(float) * 1); 254 static bool8 param10_init[] = {false}; 255 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 256 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 257 // Phase 3, inputs and outputs 258 model->identifyInputsAndOutputs( 259 {scores, roi, anchors}, 260 {scoresOut, roiOut, classesOut, detectionOut}); 261 assert(model->isValid()); 262 } 263 264 inline bool is_ignored_regular_dynamic_output_shape(int i) { 265 static std::set<int> ignore = {}; 266 return ignore.find(i) != ignore.end(); 267 } 268 269 void CreateModel_regular_dynamic_output_shape_relaxed(Model *model) { 270 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 271 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 272 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 273 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 274 OperandType type19(Type::TENSOR_INT32, {0, 0}); 275 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 276 OperandType type20(Type::TENSOR_INT32, {0}); 277 OperandType type7(Type::FLOAT32, {}); 278 OperandType type8(Type::BOOL, {}); 279 OperandType type9(Type::INT32, {}); 280 // Phase 1, operands 281 auto scores = model->addOperand(&type0); 282 auto roi = model->addOperand(&type1); 283 auto anchors = model->addOperand(&type2); 284 auto param = model->addOperand(&type7); 285 auto param1 = model->addOperand(&type7); 286 auto param2 = model->addOperand(&type7); 287 auto param3 = model->addOperand(&type7); 288 auto param4 = model->addOperand(&type8); 289 auto param5 = model->addOperand(&type9); 290 auto param6 = model->addOperand(&type9); 291 auto param7 = model->addOperand(&type9); 292 auto param8 = model->addOperand(&type7); 293 auto param9 = model->addOperand(&type7); 294 auto param10 = model->addOperand(&type8); 295 auto scoresOut = model->addOperand(&type17); 296 auto roiOut = model->addOperand(&type18); 297 auto classesOut = model->addOperand(&type19); 298 auto detectionOut = model->addOperand(&type20); 299 // Phase 2, operations 300 static float param_init[] = {10.0f}; 301 model->setOperandValue(param, param_init, sizeof(float) * 1); 302 static float param1_init[] = {10.0f}; 303 model->setOperandValue(param1, param1_init, sizeof(float) * 1); 304 static float param2_init[] = {5.0f}; 305 model->setOperandValue(param2, param2_init, sizeof(float) * 1); 306 static float param3_init[] = {5.0f}; 307 model->setOperandValue(param3, param3_init, sizeof(float) * 1); 308 static bool8 param4_init[] = {true}; 309 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 310 static int32_t param5_init[] = {3}; 311 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 312 static int32_t param6_init[] = {1}; 313 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 314 static int32_t param7_init[] = {1}; 315 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 316 static float param8_init[] = {0.0f}; 317 model->setOperandValue(param8, param8_init, sizeof(float) * 1); 318 static float param9_init[] = {0.5f}; 319 model->setOperandValue(param9, param9_init, sizeof(float) * 1); 320 static bool8 param10_init[] = {false}; 321 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 322 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 323 // Phase 3, inputs and outputs 324 model->identifyInputsAndOutputs( 325 {scores, roi, anchors}, 326 {scoresOut, roiOut, classesOut, detectionOut}); 327 // Phase 4: set relaxed execution 328 model->relaxComputationFloat32toFloat16(true); 329 assert(model->isValid()); 330 } 331 332 inline bool is_ignored_regular_dynamic_output_shape_relaxed(int i) { 333 static std::set<int> ignore = {}; 334 return ignore.find(i) != ignore.end(); 335 } 336 337 void CreateModel_regular_dynamic_output_shape_float16(Model *model) { 338 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 339 OperandType type12(Type::FLOAT16, {}); 340 OperandType type13(Type::TENSOR_FLOAT16, {1, 6, 4}); 341 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 342 OperandType type19(Type::TENSOR_INT32, {0, 0}); 343 OperandType type20(Type::TENSOR_INT32, {0}); 344 OperandType type21(Type::TENSOR_FLOAT16, {0, 0}); 345 OperandType type22(Type::TENSOR_FLOAT16, {0, 0, 0}); 346 OperandType type8(Type::BOOL, {}); 347 OperandType type9(Type::INT32, {}); 348 // Phase 1, operands 349 auto scores = model->addOperand(&type15); 350 auto roi = model->addOperand(&type13); 351 auto anchors = model->addOperand(&type11); 352 auto param = model->addOperand(&type12); 353 auto param1 = model->addOperand(&type12); 354 auto param2 = model->addOperand(&type12); 355 auto param3 = model->addOperand(&type12); 356 auto param4 = model->addOperand(&type8); 357 auto param5 = model->addOperand(&type9); 358 auto param6 = model->addOperand(&type9); 359 auto param7 = model->addOperand(&type9); 360 auto param8 = model->addOperand(&type12); 361 auto param9 = model->addOperand(&type12); 362 auto param10 = model->addOperand(&type8); 363 auto scoresOut = model->addOperand(&type21); 364 auto roiOut = model->addOperand(&type22); 365 auto classesOut = model->addOperand(&type19); 366 auto detectionOut = model->addOperand(&type20); 367 // Phase 2, operations 368 static _Float16 param_init[] = {10.0f}; 369 model->setOperandValue(param, param_init, sizeof(_Float16) * 1); 370 static _Float16 param1_init[] = {10.0f}; 371 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1); 372 static _Float16 param2_init[] = {5.0f}; 373 model->setOperandValue(param2, param2_init, sizeof(_Float16) * 1); 374 static _Float16 param3_init[] = {5.0f}; 375 model->setOperandValue(param3, param3_init, sizeof(_Float16) * 1); 376 static bool8 param4_init[] = {true}; 377 model->setOperandValue(param4, param4_init, sizeof(bool8) * 1); 378 static int32_t param5_init[] = {3}; 379 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 380 static int32_t param6_init[] = {1}; 381 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 382 static int32_t param7_init[] = {1}; 383 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 384 static _Float16 param8_init[] = {0.0f}; 385 model->setOperandValue(param8, param8_init, sizeof(_Float16) * 1); 386 static _Float16 param9_init[] = {0.5f}; 387 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1); 388 static bool8 param10_init[] = {false}; 389 model->setOperandValue(param10, param10_init, sizeof(bool8) * 1); 390 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores, roi, anchors, param, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, {scoresOut, roiOut, classesOut, detectionOut}); 391 // Phase 3, inputs and outputs 392 model->identifyInputsAndOutputs( 393 {scores, roi, anchors}, 394 {scoresOut, roiOut, classesOut, detectionOut}); 395 assert(model->isValid()); 396 } 397 398 inline bool is_ignored_regular_dynamic_output_shape_float16(int i) { 399 static std::set<int> ignore = {}; 400 return ignore.find(i) != ignore.end(); 401 } 402 403 void CreateModel(Model *model) { 404 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 405 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 406 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 407 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 408 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 409 OperandType type5(Type::TENSOR_INT32, {1, 3}); 410 OperandType type6(Type::TENSOR_INT32, {1}); 411 OperandType type7(Type::FLOAT32, {}); 412 OperandType type8(Type::BOOL, {}); 413 OperandType type9(Type::INT32, {}); 414 // Phase 1, operands 415 auto scores1 = model->addOperand(&type0); 416 auto roi1 = model->addOperand(&type1); 417 auto anchors1 = model->addOperand(&type2); 418 auto param11 = model->addOperand(&type7); 419 auto param12 = model->addOperand(&type7); 420 auto param13 = model->addOperand(&type7); 421 auto param14 = model->addOperand(&type7); 422 auto param15 = model->addOperand(&type8); 423 auto param16 = model->addOperand(&type9); 424 auto param17 = model->addOperand(&type9); 425 auto param18 = model->addOperand(&type9); 426 auto param19 = model->addOperand(&type7); 427 auto param20 = model->addOperand(&type7); 428 auto param21 = model->addOperand(&type8); 429 auto scoresOut1 = model->addOperand(&type3); 430 auto roiOut1 = model->addOperand(&type4); 431 auto classesOut1 = model->addOperand(&type5); 432 auto detectionOut1 = model->addOperand(&type6); 433 // Phase 2, operations 434 static float param11_init[] = {10.0f}; 435 model->setOperandValue(param11, param11_init, sizeof(float) * 1); 436 static float param12_init[] = {10.0f}; 437 model->setOperandValue(param12, param12_init, sizeof(float) * 1); 438 static float param13_init[] = {5.0f}; 439 model->setOperandValue(param13, param13_init, sizeof(float) * 1); 440 static float param14_init[] = {5.0f}; 441 model->setOperandValue(param14, param14_init, sizeof(float) * 1); 442 static bool8 param15_init[] = {false}; 443 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 444 static int32_t param16_init[] = {3}; 445 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 446 static int32_t param17_init[] = {1}; 447 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 448 static int32_t param18_init[] = {1}; 449 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 450 static float param19_init[] = {0.0f}; 451 model->setOperandValue(param19, param19_init, sizeof(float) * 1); 452 static float param20_init[] = {0.5f}; 453 model->setOperandValue(param20, param20_init, sizeof(float) * 1); 454 static bool8 param21_init[] = {false}; 455 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 456 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 457 // Phase 3, inputs and outputs 458 model->identifyInputsAndOutputs( 459 {scores1, roi1, anchors1}, 460 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 461 assert(model->isValid()); 462 } 463 464 inline bool is_ignored(int i) { 465 static std::set<int> ignore = {}; 466 return ignore.find(i) != ignore.end(); 467 } 468 469 void CreateModel_relaxed(Model *model) { 470 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 471 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 472 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 473 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 474 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 475 OperandType type5(Type::TENSOR_INT32, {1, 3}); 476 OperandType type6(Type::TENSOR_INT32, {1}); 477 OperandType type7(Type::FLOAT32, {}); 478 OperandType type8(Type::BOOL, {}); 479 OperandType type9(Type::INT32, {}); 480 // Phase 1, operands 481 auto scores1 = model->addOperand(&type0); 482 auto roi1 = model->addOperand(&type1); 483 auto anchors1 = model->addOperand(&type2); 484 auto param11 = model->addOperand(&type7); 485 auto param12 = model->addOperand(&type7); 486 auto param13 = model->addOperand(&type7); 487 auto param14 = model->addOperand(&type7); 488 auto param15 = model->addOperand(&type8); 489 auto param16 = model->addOperand(&type9); 490 auto param17 = model->addOperand(&type9); 491 auto param18 = model->addOperand(&type9); 492 auto param19 = model->addOperand(&type7); 493 auto param20 = model->addOperand(&type7); 494 auto param21 = model->addOperand(&type8); 495 auto scoresOut1 = model->addOperand(&type3); 496 auto roiOut1 = model->addOperand(&type4); 497 auto classesOut1 = model->addOperand(&type5); 498 auto detectionOut1 = model->addOperand(&type6); 499 // Phase 2, operations 500 static float param11_init[] = {10.0f}; 501 model->setOperandValue(param11, param11_init, sizeof(float) * 1); 502 static float param12_init[] = {10.0f}; 503 model->setOperandValue(param12, param12_init, sizeof(float) * 1); 504 static float param13_init[] = {5.0f}; 505 model->setOperandValue(param13, param13_init, sizeof(float) * 1); 506 static float param14_init[] = {5.0f}; 507 model->setOperandValue(param14, param14_init, sizeof(float) * 1); 508 static bool8 param15_init[] = {false}; 509 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 510 static int32_t param16_init[] = {3}; 511 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 512 static int32_t param17_init[] = {1}; 513 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 514 static int32_t param18_init[] = {1}; 515 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 516 static float param19_init[] = {0.0f}; 517 model->setOperandValue(param19, param19_init, sizeof(float) * 1); 518 static float param20_init[] = {0.5f}; 519 model->setOperandValue(param20, param20_init, sizeof(float) * 1); 520 static bool8 param21_init[] = {false}; 521 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 522 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 523 // Phase 3, inputs and outputs 524 model->identifyInputsAndOutputs( 525 {scores1, roi1, anchors1}, 526 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 527 // Phase 4: set relaxed execution 528 model->relaxComputationFloat32toFloat16(true); 529 assert(model->isValid()); 530 } 531 532 inline bool is_ignored_relaxed(int i) { 533 static std::set<int> ignore = {}; 534 return ignore.find(i) != ignore.end(); 535 } 536 537 void CreateModel_float16(Model *model) { 538 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 539 OperandType type12(Type::FLOAT16, {}); 540 OperandType type13(Type::TENSOR_FLOAT16, {1, 6, 4}); 541 OperandType type14(Type::TENSOR_FLOAT16, {1, 3, 4}); 542 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 543 OperandType type16(Type::TENSOR_FLOAT16, {1, 3}); 544 OperandType type5(Type::TENSOR_INT32, {1, 3}); 545 OperandType type6(Type::TENSOR_INT32, {1}); 546 OperandType type8(Type::BOOL, {}); 547 OperandType type9(Type::INT32, {}); 548 // Phase 1, operands 549 auto scores1 = model->addOperand(&type15); 550 auto roi1 = model->addOperand(&type13); 551 auto anchors1 = model->addOperand(&type11); 552 auto param11 = model->addOperand(&type12); 553 auto param12 = model->addOperand(&type12); 554 auto param13 = model->addOperand(&type12); 555 auto param14 = model->addOperand(&type12); 556 auto param15 = model->addOperand(&type8); 557 auto param16 = model->addOperand(&type9); 558 auto param17 = model->addOperand(&type9); 559 auto param18 = model->addOperand(&type9); 560 auto param19 = model->addOperand(&type12); 561 auto param20 = model->addOperand(&type12); 562 auto param21 = model->addOperand(&type8); 563 auto scoresOut1 = model->addOperand(&type16); 564 auto roiOut1 = model->addOperand(&type14); 565 auto classesOut1 = model->addOperand(&type5); 566 auto detectionOut1 = model->addOperand(&type6); 567 // Phase 2, operations 568 static _Float16 param11_init[] = {10.0f}; 569 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1); 570 static _Float16 param12_init[] = {10.0f}; 571 model->setOperandValue(param12, param12_init, sizeof(_Float16) * 1); 572 static _Float16 param13_init[] = {5.0f}; 573 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1); 574 static _Float16 param14_init[] = {5.0f}; 575 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1); 576 static bool8 param15_init[] = {false}; 577 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 578 static int32_t param16_init[] = {3}; 579 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 580 static int32_t param17_init[] = {1}; 581 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 582 static int32_t param18_init[] = {1}; 583 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 584 static _Float16 param19_init[] = {0.0f}; 585 model->setOperandValue(param19, param19_init, sizeof(_Float16) * 1); 586 static _Float16 param20_init[] = {0.5f}; 587 model->setOperandValue(param20, param20_init, sizeof(_Float16) * 1); 588 static bool8 param21_init[] = {false}; 589 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 590 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 591 // Phase 3, inputs and outputs 592 model->identifyInputsAndOutputs( 593 {scores1, roi1, anchors1}, 594 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 595 assert(model->isValid()); 596 } 597 598 inline bool is_ignored_float16(int i) { 599 static std::set<int> ignore = {}; 600 return ignore.find(i) != ignore.end(); 601 } 602 603 void CreateModel_dynamic_output_shape(Model *model) { 604 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 605 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 606 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 607 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 608 OperandType type19(Type::TENSOR_INT32, {0, 0}); 609 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 610 OperandType type20(Type::TENSOR_INT32, {0}); 611 OperandType type7(Type::FLOAT32, {}); 612 OperandType type8(Type::BOOL, {}); 613 OperandType type9(Type::INT32, {}); 614 // Phase 1, operands 615 auto scores1 = model->addOperand(&type0); 616 auto roi1 = model->addOperand(&type1); 617 auto anchors1 = model->addOperand(&type2); 618 auto param11 = model->addOperand(&type7); 619 auto param12 = model->addOperand(&type7); 620 auto param13 = model->addOperand(&type7); 621 auto param14 = model->addOperand(&type7); 622 auto param15 = model->addOperand(&type8); 623 auto param16 = model->addOperand(&type9); 624 auto param17 = model->addOperand(&type9); 625 auto param18 = model->addOperand(&type9); 626 auto param19 = model->addOperand(&type7); 627 auto param20 = model->addOperand(&type7); 628 auto param21 = model->addOperand(&type8); 629 auto scoresOut1 = model->addOperand(&type17); 630 auto roiOut1 = model->addOperand(&type18); 631 auto classesOut1 = model->addOperand(&type19); 632 auto detectionOut1 = model->addOperand(&type20); 633 // Phase 2, operations 634 static float param11_init[] = {10.0f}; 635 model->setOperandValue(param11, param11_init, sizeof(float) * 1); 636 static float param12_init[] = {10.0f}; 637 model->setOperandValue(param12, param12_init, sizeof(float) * 1); 638 static float param13_init[] = {5.0f}; 639 model->setOperandValue(param13, param13_init, sizeof(float) * 1); 640 static float param14_init[] = {5.0f}; 641 model->setOperandValue(param14, param14_init, sizeof(float) * 1); 642 static bool8 param15_init[] = {false}; 643 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 644 static int32_t param16_init[] = {3}; 645 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 646 static int32_t param17_init[] = {1}; 647 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 648 static int32_t param18_init[] = {1}; 649 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 650 static float param19_init[] = {0.0f}; 651 model->setOperandValue(param19, param19_init, sizeof(float) * 1); 652 static float param20_init[] = {0.5f}; 653 model->setOperandValue(param20, param20_init, sizeof(float) * 1); 654 static bool8 param21_init[] = {false}; 655 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 656 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 657 // Phase 3, inputs and outputs 658 model->identifyInputsAndOutputs( 659 {scores1, roi1, anchors1}, 660 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 661 assert(model->isValid()); 662 } 663 664 inline bool is_ignored_dynamic_output_shape(int i) { 665 static std::set<int> ignore = {}; 666 return ignore.find(i) != ignore.end(); 667 } 668 669 void CreateModel_dynamic_output_shape_relaxed(Model *model) { 670 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 671 OperandType type1(Type::TENSOR_FLOAT32, {1, 6, 4}); 672 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 673 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 674 OperandType type19(Type::TENSOR_INT32, {0, 0}); 675 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 676 OperandType type20(Type::TENSOR_INT32, {0}); 677 OperandType type7(Type::FLOAT32, {}); 678 OperandType type8(Type::BOOL, {}); 679 OperandType type9(Type::INT32, {}); 680 // Phase 1, operands 681 auto scores1 = model->addOperand(&type0); 682 auto roi1 = model->addOperand(&type1); 683 auto anchors1 = model->addOperand(&type2); 684 auto param11 = model->addOperand(&type7); 685 auto param12 = model->addOperand(&type7); 686 auto param13 = model->addOperand(&type7); 687 auto param14 = model->addOperand(&type7); 688 auto param15 = model->addOperand(&type8); 689 auto param16 = model->addOperand(&type9); 690 auto param17 = model->addOperand(&type9); 691 auto param18 = model->addOperand(&type9); 692 auto param19 = model->addOperand(&type7); 693 auto param20 = model->addOperand(&type7); 694 auto param21 = model->addOperand(&type8); 695 auto scoresOut1 = model->addOperand(&type17); 696 auto roiOut1 = model->addOperand(&type18); 697 auto classesOut1 = model->addOperand(&type19); 698 auto detectionOut1 = model->addOperand(&type20); 699 // Phase 2, operations 700 static float param11_init[] = {10.0f}; 701 model->setOperandValue(param11, param11_init, sizeof(float) * 1); 702 static float param12_init[] = {10.0f}; 703 model->setOperandValue(param12, param12_init, sizeof(float) * 1); 704 static float param13_init[] = {5.0f}; 705 model->setOperandValue(param13, param13_init, sizeof(float) * 1); 706 static float param14_init[] = {5.0f}; 707 model->setOperandValue(param14, param14_init, sizeof(float) * 1); 708 static bool8 param15_init[] = {false}; 709 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 710 static int32_t param16_init[] = {3}; 711 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 712 static int32_t param17_init[] = {1}; 713 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 714 static int32_t param18_init[] = {1}; 715 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 716 static float param19_init[] = {0.0f}; 717 model->setOperandValue(param19, param19_init, sizeof(float) * 1); 718 static float param20_init[] = {0.5f}; 719 model->setOperandValue(param20, param20_init, sizeof(float) * 1); 720 static bool8 param21_init[] = {false}; 721 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 722 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 723 // Phase 3, inputs and outputs 724 model->identifyInputsAndOutputs( 725 {scores1, roi1, anchors1}, 726 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 727 // Phase 4: set relaxed execution 728 model->relaxComputationFloat32toFloat16(true); 729 assert(model->isValid()); 730 } 731 732 inline bool is_ignored_dynamic_output_shape_relaxed(int i) { 733 static std::set<int> ignore = {}; 734 return ignore.find(i) != ignore.end(); 735 } 736 737 void CreateModel_dynamic_output_shape_float16(Model *model) { 738 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 739 OperandType type12(Type::FLOAT16, {}); 740 OperandType type13(Type::TENSOR_FLOAT16, {1, 6, 4}); 741 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 742 OperandType type19(Type::TENSOR_INT32, {0, 0}); 743 OperandType type20(Type::TENSOR_INT32, {0}); 744 OperandType type21(Type::TENSOR_FLOAT16, {0, 0}); 745 OperandType type22(Type::TENSOR_FLOAT16, {0, 0, 0}); 746 OperandType type8(Type::BOOL, {}); 747 OperandType type9(Type::INT32, {}); 748 // Phase 1, operands 749 auto scores1 = model->addOperand(&type15); 750 auto roi1 = model->addOperand(&type13); 751 auto anchors1 = model->addOperand(&type11); 752 auto param11 = model->addOperand(&type12); 753 auto param12 = model->addOperand(&type12); 754 auto param13 = model->addOperand(&type12); 755 auto param14 = model->addOperand(&type12); 756 auto param15 = model->addOperand(&type8); 757 auto param16 = model->addOperand(&type9); 758 auto param17 = model->addOperand(&type9); 759 auto param18 = model->addOperand(&type9); 760 auto param19 = model->addOperand(&type12); 761 auto param20 = model->addOperand(&type12); 762 auto param21 = model->addOperand(&type8); 763 auto scoresOut1 = model->addOperand(&type21); 764 auto roiOut1 = model->addOperand(&type22); 765 auto classesOut1 = model->addOperand(&type19); 766 auto detectionOut1 = model->addOperand(&type20); 767 // Phase 2, operations 768 static _Float16 param11_init[] = {10.0f}; 769 model->setOperandValue(param11, param11_init, sizeof(_Float16) * 1); 770 static _Float16 param12_init[] = {10.0f}; 771 model->setOperandValue(param12, param12_init, sizeof(_Float16) * 1); 772 static _Float16 param13_init[] = {5.0f}; 773 model->setOperandValue(param13, param13_init, sizeof(_Float16) * 1); 774 static _Float16 param14_init[] = {5.0f}; 775 model->setOperandValue(param14, param14_init, sizeof(_Float16) * 1); 776 static bool8 param15_init[] = {false}; 777 model->setOperandValue(param15, param15_init, sizeof(bool8) * 1); 778 static int32_t param16_init[] = {3}; 779 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 780 static int32_t param17_init[] = {1}; 781 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 782 static int32_t param18_init[] = {1}; 783 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 784 static _Float16 param19_init[] = {0.0f}; 785 model->setOperandValue(param19, param19_init, sizeof(_Float16) * 1); 786 static _Float16 param20_init[] = {0.5f}; 787 model->setOperandValue(param20, param20_init, sizeof(_Float16) * 1); 788 static bool8 param21_init[] = {false}; 789 model->setOperandValue(param21, param21_init, sizeof(bool8) * 1); 790 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores1, roi1, anchors1, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20, param21}, {scoresOut1, roiOut1, classesOut1, detectionOut1}); 791 // Phase 3, inputs and outputs 792 model->identifyInputsAndOutputs( 793 {scores1, roi1, anchors1}, 794 {scoresOut1, roiOut1, classesOut1, detectionOut1}); 795 assert(model->isValid()); 796 } 797 798 inline bool is_ignored_dynamic_output_shape_float16(int i) { 799 static std::set<int> ignore = {}; 800 return ignore.find(i) != ignore.end(); 801 } 802 803 void CreateModel_2(Model *model) { 804 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 805 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 806 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 807 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 808 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 809 OperandType type5(Type::TENSOR_INT32, {1, 3}); 810 OperandType type6(Type::TENSOR_INT32, {1}); 811 OperandType type7(Type::FLOAT32, {}); 812 OperandType type8(Type::BOOL, {}); 813 OperandType type9(Type::INT32, {}); 814 // Phase 1, operands 815 auto scores2 = model->addOperand(&type0); 816 auto roi2 = model->addOperand(&type10); 817 auto anchors2 = model->addOperand(&type2); 818 auto param22 = model->addOperand(&type7); 819 auto param23 = model->addOperand(&type7); 820 auto param24 = model->addOperand(&type7); 821 auto param25 = model->addOperand(&type7); 822 auto param26 = model->addOperand(&type8); 823 auto param27 = model->addOperand(&type9); 824 auto param28 = model->addOperand(&type9); 825 auto param29 = model->addOperand(&type9); 826 auto param30 = model->addOperand(&type7); 827 auto param31 = model->addOperand(&type7); 828 auto param32 = model->addOperand(&type8); 829 auto scoresOut2 = model->addOperand(&type3); 830 auto roiOut2 = model->addOperand(&type4); 831 auto classesOut2 = model->addOperand(&type5); 832 auto detectionOut2 = model->addOperand(&type6); 833 // Phase 2, operations 834 static float param22_init[] = {10.0f}; 835 model->setOperandValue(param22, param22_init, sizeof(float) * 1); 836 static float param23_init[] = {10.0f}; 837 model->setOperandValue(param23, param23_init, sizeof(float) * 1); 838 static float param24_init[] = {5.0f}; 839 model->setOperandValue(param24, param24_init, sizeof(float) * 1); 840 static float param25_init[] = {5.0f}; 841 model->setOperandValue(param25, param25_init, sizeof(float) * 1); 842 static bool8 param26_init[] = {false}; 843 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 844 static int32_t param27_init[] = {3}; 845 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 846 static int32_t param28_init[] = {1}; 847 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 848 static int32_t param29_init[] = {1}; 849 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 850 static float param30_init[] = {0.0f}; 851 model->setOperandValue(param30, param30_init, sizeof(float) * 1); 852 static float param31_init[] = {0.5f}; 853 model->setOperandValue(param31, param31_init, sizeof(float) * 1); 854 static bool8 param32_init[] = {false}; 855 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 856 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 857 // Phase 3, inputs and outputs 858 model->identifyInputsAndOutputs( 859 {scores2, roi2, anchors2}, 860 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 861 assert(model->isValid()); 862 } 863 864 inline bool is_ignored_2(int i) { 865 static std::set<int> ignore = {}; 866 return ignore.find(i) != ignore.end(); 867 } 868 869 void CreateModel_relaxed_2(Model *model) { 870 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 871 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 872 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 873 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 874 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 875 OperandType type5(Type::TENSOR_INT32, {1, 3}); 876 OperandType type6(Type::TENSOR_INT32, {1}); 877 OperandType type7(Type::FLOAT32, {}); 878 OperandType type8(Type::BOOL, {}); 879 OperandType type9(Type::INT32, {}); 880 // Phase 1, operands 881 auto scores2 = model->addOperand(&type0); 882 auto roi2 = model->addOperand(&type10); 883 auto anchors2 = model->addOperand(&type2); 884 auto param22 = model->addOperand(&type7); 885 auto param23 = model->addOperand(&type7); 886 auto param24 = model->addOperand(&type7); 887 auto param25 = model->addOperand(&type7); 888 auto param26 = model->addOperand(&type8); 889 auto param27 = model->addOperand(&type9); 890 auto param28 = model->addOperand(&type9); 891 auto param29 = model->addOperand(&type9); 892 auto param30 = model->addOperand(&type7); 893 auto param31 = model->addOperand(&type7); 894 auto param32 = model->addOperand(&type8); 895 auto scoresOut2 = model->addOperand(&type3); 896 auto roiOut2 = model->addOperand(&type4); 897 auto classesOut2 = model->addOperand(&type5); 898 auto detectionOut2 = model->addOperand(&type6); 899 // Phase 2, operations 900 static float param22_init[] = {10.0f}; 901 model->setOperandValue(param22, param22_init, sizeof(float) * 1); 902 static float param23_init[] = {10.0f}; 903 model->setOperandValue(param23, param23_init, sizeof(float) * 1); 904 static float param24_init[] = {5.0f}; 905 model->setOperandValue(param24, param24_init, sizeof(float) * 1); 906 static float param25_init[] = {5.0f}; 907 model->setOperandValue(param25, param25_init, sizeof(float) * 1); 908 static bool8 param26_init[] = {false}; 909 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 910 static int32_t param27_init[] = {3}; 911 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 912 static int32_t param28_init[] = {1}; 913 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 914 static int32_t param29_init[] = {1}; 915 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 916 static float param30_init[] = {0.0f}; 917 model->setOperandValue(param30, param30_init, sizeof(float) * 1); 918 static float param31_init[] = {0.5f}; 919 model->setOperandValue(param31, param31_init, sizeof(float) * 1); 920 static bool8 param32_init[] = {false}; 921 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 922 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 923 // Phase 3, inputs and outputs 924 model->identifyInputsAndOutputs( 925 {scores2, roi2, anchors2}, 926 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 927 // Phase 4: set relaxed execution 928 model->relaxComputationFloat32toFloat16(true); 929 assert(model->isValid()); 930 } 931 932 inline bool is_ignored_relaxed_2(int i) { 933 static std::set<int> ignore = {}; 934 return ignore.find(i) != ignore.end(); 935 } 936 937 void CreateModel_float16_2(Model *model) { 938 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 939 OperandType type12(Type::FLOAT16, {}); 940 OperandType type14(Type::TENSOR_FLOAT16, {1, 3, 4}); 941 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 942 OperandType type16(Type::TENSOR_FLOAT16, {1, 3}); 943 OperandType type23(Type::TENSOR_FLOAT16, {1, 6, 7}); 944 OperandType type5(Type::TENSOR_INT32, {1, 3}); 945 OperandType type6(Type::TENSOR_INT32, {1}); 946 OperandType type8(Type::BOOL, {}); 947 OperandType type9(Type::INT32, {}); 948 // Phase 1, operands 949 auto scores2 = model->addOperand(&type15); 950 auto roi2 = model->addOperand(&type23); 951 auto anchors2 = model->addOperand(&type11); 952 auto param22 = model->addOperand(&type12); 953 auto param23 = model->addOperand(&type12); 954 auto param24 = model->addOperand(&type12); 955 auto param25 = model->addOperand(&type12); 956 auto param26 = model->addOperand(&type8); 957 auto param27 = model->addOperand(&type9); 958 auto param28 = model->addOperand(&type9); 959 auto param29 = model->addOperand(&type9); 960 auto param30 = model->addOperand(&type12); 961 auto param31 = model->addOperand(&type12); 962 auto param32 = model->addOperand(&type8); 963 auto scoresOut2 = model->addOperand(&type16); 964 auto roiOut2 = model->addOperand(&type14); 965 auto classesOut2 = model->addOperand(&type5); 966 auto detectionOut2 = model->addOperand(&type6); 967 // Phase 2, operations 968 static _Float16 param22_init[] = {10.0f}; 969 model->setOperandValue(param22, param22_init, sizeof(_Float16) * 1); 970 static _Float16 param23_init[] = {10.0f}; 971 model->setOperandValue(param23, param23_init, sizeof(_Float16) * 1); 972 static _Float16 param24_init[] = {5.0f}; 973 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1); 974 static _Float16 param25_init[] = {5.0f}; 975 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1); 976 static bool8 param26_init[] = {false}; 977 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 978 static int32_t param27_init[] = {3}; 979 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 980 static int32_t param28_init[] = {1}; 981 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 982 static int32_t param29_init[] = {1}; 983 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 984 static _Float16 param30_init[] = {0.0f}; 985 model->setOperandValue(param30, param30_init, sizeof(_Float16) * 1); 986 static _Float16 param31_init[] = {0.5f}; 987 model->setOperandValue(param31, param31_init, sizeof(_Float16) * 1); 988 static bool8 param32_init[] = {false}; 989 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 990 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 991 // Phase 3, inputs and outputs 992 model->identifyInputsAndOutputs( 993 {scores2, roi2, anchors2}, 994 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 995 assert(model->isValid()); 996 } 997 998 inline bool is_ignored_float16_2(int i) { 999 static std::set<int> ignore = {}; 1000 return ignore.find(i) != ignore.end(); 1001 } 1002 1003 void CreateModel_dynamic_output_shape_2(Model *model) { 1004 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1005 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1006 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 1007 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 1008 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1009 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1010 OperandType type20(Type::TENSOR_INT32, {0}); 1011 OperandType type7(Type::FLOAT32, {}); 1012 OperandType type8(Type::BOOL, {}); 1013 OperandType type9(Type::INT32, {}); 1014 // Phase 1, operands 1015 auto scores2 = model->addOperand(&type0); 1016 auto roi2 = model->addOperand(&type10); 1017 auto anchors2 = model->addOperand(&type2); 1018 auto param22 = model->addOperand(&type7); 1019 auto param23 = model->addOperand(&type7); 1020 auto param24 = model->addOperand(&type7); 1021 auto param25 = model->addOperand(&type7); 1022 auto param26 = model->addOperand(&type8); 1023 auto param27 = model->addOperand(&type9); 1024 auto param28 = model->addOperand(&type9); 1025 auto param29 = model->addOperand(&type9); 1026 auto param30 = model->addOperand(&type7); 1027 auto param31 = model->addOperand(&type7); 1028 auto param32 = model->addOperand(&type8); 1029 auto scoresOut2 = model->addOperand(&type17); 1030 auto roiOut2 = model->addOperand(&type18); 1031 auto classesOut2 = model->addOperand(&type19); 1032 auto detectionOut2 = model->addOperand(&type20); 1033 // Phase 2, operations 1034 static float param22_init[] = {10.0f}; 1035 model->setOperandValue(param22, param22_init, sizeof(float) * 1); 1036 static float param23_init[] = {10.0f}; 1037 model->setOperandValue(param23, param23_init, sizeof(float) * 1); 1038 static float param24_init[] = {5.0f}; 1039 model->setOperandValue(param24, param24_init, sizeof(float) * 1); 1040 static float param25_init[] = {5.0f}; 1041 model->setOperandValue(param25, param25_init, sizeof(float) * 1); 1042 static bool8 param26_init[] = {false}; 1043 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 1044 static int32_t param27_init[] = {3}; 1045 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 1046 static int32_t param28_init[] = {1}; 1047 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 1048 static int32_t param29_init[] = {1}; 1049 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 1050 static float param30_init[] = {0.0f}; 1051 model->setOperandValue(param30, param30_init, sizeof(float) * 1); 1052 static float param31_init[] = {0.5f}; 1053 model->setOperandValue(param31, param31_init, sizeof(float) * 1); 1054 static bool8 param32_init[] = {false}; 1055 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 1056 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1057 // Phase 3, inputs and outputs 1058 model->identifyInputsAndOutputs( 1059 {scores2, roi2, anchors2}, 1060 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1061 assert(model->isValid()); 1062 } 1063 1064 inline bool is_ignored_dynamic_output_shape_2(int i) { 1065 static std::set<int> ignore = {}; 1066 return ignore.find(i) != ignore.end(); 1067 } 1068 1069 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) { 1070 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1071 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1072 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 1073 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 1074 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1075 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1076 OperandType type20(Type::TENSOR_INT32, {0}); 1077 OperandType type7(Type::FLOAT32, {}); 1078 OperandType type8(Type::BOOL, {}); 1079 OperandType type9(Type::INT32, {}); 1080 // Phase 1, operands 1081 auto scores2 = model->addOperand(&type0); 1082 auto roi2 = model->addOperand(&type10); 1083 auto anchors2 = model->addOperand(&type2); 1084 auto param22 = model->addOperand(&type7); 1085 auto param23 = model->addOperand(&type7); 1086 auto param24 = model->addOperand(&type7); 1087 auto param25 = model->addOperand(&type7); 1088 auto param26 = model->addOperand(&type8); 1089 auto param27 = model->addOperand(&type9); 1090 auto param28 = model->addOperand(&type9); 1091 auto param29 = model->addOperand(&type9); 1092 auto param30 = model->addOperand(&type7); 1093 auto param31 = model->addOperand(&type7); 1094 auto param32 = model->addOperand(&type8); 1095 auto scoresOut2 = model->addOperand(&type17); 1096 auto roiOut2 = model->addOperand(&type18); 1097 auto classesOut2 = model->addOperand(&type19); 1098 auto detectionOut2 = model->addOperand(&type20); 1099 // Phase 2, operations 1100 static float param22_init[] = {10.0f}; 1101 model->setOperandValue(param22, param22_init, sizeof(float) * 1); 1102 static float param23_init[] = {10.0f}; 1103 model->setOperandValue(param23, param23_init, sizeof(float) * 1); 1104 static float param24_init[] = {5.0f}; 1105 model->setOperandValue(param24, param24_init, sizeof(float) * 1); 1106 static float param25_init[] = {5.0f}; 1107 model->setOperandValue(param25, param25_init, sizeof(float) * 1); 1108 static bool8 param26_init[] = {false}; 1109 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 1110 static int32_t param27_init[] = {3}; 1111 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 1112 static int32_t param28_init[] = {1}; 1113 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 1114 static int32_t param29_init[] = {1}; 1115 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 1116 static float param30_init[] = {0.0f}; 1117 model->setOperandValue(param30, param30_init, sizeof(float) * 1); 1118 static float param31_init[] = {0.5f}; 1119 model->setOperandValue(param31, param31_init, sizeof(float) * 1); 1120 static bool8 param32_init[] = {false}; 1121 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 1122 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1123 // Phase 3, inputs and outputs 1124 model->identifyInputsAndOutputs( 1125 {scores2, roi2, anchors2}, 1126 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1127 // Phase 4: set relaxed execution 1128 model->relaxComputationFloat32toFloat16(true); 1129 assert(model->isValid()); 1130 } 1131 1132 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) { 1133 static std::set<int> ignore = {}; 1134 return ignore.find(i) != ignore.end(); 1135 } 1136 1137 void CreateModel_dynamic_output_shape_float16_2(Model *model) { 1138 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 1139 OperandType type12(Type::FLOAT16, {}); 1140 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 1141 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1142 OperandType type20(Type::TENSOR_INT32, {0}); 1143 OperandType type21(Type::TENSOR_FLOAT16, {0, 0}); 1144 OperandType type22(Type::TENSOR_FLOAT16, {0, 0, 0}); 1145 OperandType type23(Type::TENSOR_FLOAT16, {1, 6, 7}); 1146 OperandType type8(Type::BOOL, {}); 1147 OperandType type9(Type::INT32, {}); 1148 // Phase 1, operands 1149 auto scores2 = model->addOperand(&type15); 1150 auto roi2 = model->addOperand(&type23); 1151 auto anchors2 = model->addOperand(&type11); 1152 auto param22 = model->addOperand(&type12); 1153 auto param23 = model->addOperand(&type12); 1154 auto param24 = model->addOperand(&type12); 1155 auto param25 = model->addOperand(&type12); 1156 auto param26 = model->addOperand(&type8); 1157 auto param27 = model->addOperand(&type9); 1158 auto param28 = model->addOperand(&type9); 1159 auto param29 = model->addOperand(&type9); 1160 auto param30 = model->addOperand(&type12); 1161 auto param31 = model->addOperand(&type12); 1162 auto param32 = model->addOperand(&type8); 1163 auto scoresOut2 = model->addOperand(&type21); 1164 auto roiOut2 = model->addOperand(&type22); 1165 auto classesOut2 = model->addOperand(&type19); 1166 auto detectionOut2 = model->addOperand(&type20); 1167 // Phase 2, operations 1168 static _Float16 param22_init[] = {10.0f}; 1169 model->setOperandValue(param22, param22_init, sizeof(_Float16) * 1); 1170 static _Float16 param23_init[] = {10.0f}; 1171 model->setOperandValue(param23, param23_init, sizeof(_Float16) * 1); 1172 static _Float16 param24_init[] = {5.0f}; 1173 model->setOperandValue(param24, param24_init, sizeof(_Float16) * 1); 1174 static _Float16 param25_init[] = {5.0f}; 1175 model->setOperandValue(param25, param25_init, sizeof(_Float16) * 1); 1176 static bool8 param26_init[] = {false}; 1177 model->setOperandValue(param26, param26_init, sizeof(bool8) * 1); 1178 static int32_t param27_init[] = {3}; 1179 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 1180 static int32_t param28_init[] = {1}; 1181 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 1182 static int32_t param29_init[] = {1}; 1183 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 1184 static _Float16 param30_init[] = {0.0f}; 1185 model->setOperandValue(param30, param30_init, sizeof(_Float16) * 1); 1186 static _Float16 param31_init[] = {0.5f}; 1187 model->setOperandValue(param31, param31_init, sizeof(_Float16) * 1); 1188 static bool8 param32_init[] = {false}; 1189 model->setOperandValue(param32, param32_init, sizeof(bool8) * 1); 1190 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores2, roi2, anchors2, param22, param23, param24, param25, param26, param27, param28, param29, param30, param31, param32}, {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1191 // Phase 3, inputs and outputs 1192 model->identifyInputsAndOutputs( 1193 {scores2, roi2, anchors2}, 1194 {scoresOut2, roiOut2, classesOut2, detectionOut2}); 1195 assert(model->isValid()); 1196 } 1197 1198 inline bool is_ignored_dynamic_output_shape_float16_2(int i) { 1199 static std::set<int> ignore = {}; 1200 return ignore.find(i) != ignore.end(); 1201 } 1202 1203 void CreateModel_3(Model *model) { 1204 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1205 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1206 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1207 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 1208 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 1209 OperandType type5(Type::TENSOR_INT32, {1, 3}); 1210 OperandType type6(Type::TENSOR_INT32, {1}); 1211 OperandType type7(Type::FLOAT32, {}); 1212 OperandType type8(Type::BOOL, {}); 1213 OperandType type9(Type::INT32, {}); 1214 // Phase 1, operands 1215 auto scores3 = model->addOperand(&type0); 1216 auto roi3 = model->addOperand(&type10); 1217 auto anchors3 = model->addOperand(&type2); 1218 auto param33 = model->addOperand(&type7); 1219 auto param34 = model->addOperand(&type7); 1220 auto param35 = model->addOperand(&type7); 1221 auto param36 = model->addOperand(&type7); 1222 auto param37 = model->addOperand(&type8); 1223 auto param38 = model->addOperand(&type9); 1224 auto param39 = model->addOperand(&type9); 1225 auto param40 = model->addOperand(&type9); 1226 auto param41 = model->addOperand(&type7); 1227 auto param42 = model->addOperand(&type7); 1228 auto param43 = model->addOperand(&type8); 1229 auto scoresOut3 = model->addOperand(&type3); 1230 auto roiOut3 = model->addOperand(&type4); 1231 auto classesOut3 = model->addOperand(&type5); 1232 auto detectionOut3 = model->addOperand(&type6); 1233 // Phase 2, operations 1234 static float param33_init[] = {10.0f}; 1235 model->setOperandValue(param33, param33_init, sizeof(float) * 1); 1236 static float param34_init[] = {10.0f}; 1237 model->setOperandValue(param34, param34_init, sizeof(float) * 1); 1238 static float param35_init[] = {5.0f}; 1239 model->setOperandValue(param35, param35_init, sizeof(float) * 1); 1240 static float param36_init[] = {5.0f}; 1241 model->setOperandValue(param36, param36_init, sizeof(float) * 1); 1242 static bool8 param37_init[] = {false}; 1243 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1244 static int32_t param38_init[] = {3}; 1245 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1246 static int32_t param39_init[] = {1}; 1247 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1248 static int32_t param40_init[] = {1}; 1249 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1250 static float param41_init[] = {0.0f}; 1251 model->setOperandValue(param41, param41_init, sizeof(float) * 1); 1252 static float param42_init[] = {0.5f}; 1253 model->setOperandValue(param42, param42_init, sizeof(float) * 1); 1254 static bool8 param43_init[] = {true}; 1255 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1256 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1257 // Phase 3, inputs and outputs 1258 model->identifyInputsAndOutputs( 1259 {scores3, roi3, anchors3}, 1260 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1261 assert(model->isValid()); 1262 } 1263 1264 inline bool is_ignored_3(int i) { 1265 static std::set<int> ignore = {}; 1266 return ignore.find(i) != ignore.end(); 1267 } 1268 1269 void CreateModel_relaxed_3(Model *model) { 1270 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1271 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1272 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1273 OperandType type3(Type::TENSOR_FLOAT32, {1, 3}); 1274 OperandType type4(Type::TENSOR_FLOAT32, {1, 3, 4}); 1275 OperandType type5(Type::TENSOR_INT32, {1, 3}); 1276 OperandType type6(Type::TENSOR_INT32, {1}); 1277 OperandType type7(Type::FLOAT32, {}); 1278 OperandType type8(Type::BOOL, {}); 1279 OperandType type9(Type::INT32, {}); 1280 // Phase 1, operands 1281 auto scores3 = model->addOperand(&type0); 1282 auto roi3 = model->addOperand(&type10); 1283 auto anchors3 = model->addOperand(&type2); 1284 auto param33 = model->addOperand(&type7); 1285 auto param34 = model->addOperand(&type7); 1286 auto param35 = model->addOperand(&type7); 1287 auto param36 = model->addOperand(&type7); 1288 auto param37 = model->addOperand(&type8); 1289 auto param38 = model->addOperand(&type9); 1290 auto param39 = model->addOperand(&type9); 1291 auto param40 = model->addOperand(&type9); 1292 auto param41 = model->addOperand(&type7); 1293 auto param42 = model->addOperand(&type7); 1294 auto param43 = model->addOperand(&type8); 1295 auto scoresOut3 = model->addOperand(&type3); 1296 auto roiOut3 = model->addOperand(&type4); 1297 auto classesOut3 = model->addOperand(&type5); 1298 auto detectionOut3 = model->addOperand(&type6); 1299 // Phase 2, operations 1300 static float param33_init[] = {10.0f}; 1301 model->setOperandValue(param33, param33_init, sizeof(float) * 1); 1302 static float param34_init[] = {10.0f}; 1303 model->setOperandValue(param34, param34_init, sizeof(float) * 1); 1304 static float param35_init[] = {5.0f}; 1305 model->setOperandValue(param35, param35_init, sizeof(float) * 1); 1306 static float param36_init[] = {5.0f}; 1307 model->setOperandValue(param36, param36_init, sizeof(float) * 1); 1308 static bool8 param37_init[] = {false}; 1309 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1310 static int32_t param38_init[] = {3}; 1311 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1312 static int32_t param39_init[] = {1}; 1313 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1314 static int32_t param40_init[] = {1}; 1315 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1316 static float param41_init[] = {0.0f}; 1317 model->setOperandValue(param41, param41_init, sizeof(float) * 1); 1318 static float param42_init[] = {0.5f}; 1319 model->setOperandValue(param42, param42_init, sizeof(float) * 1); 1320 static bool8 param43_init[] = {true}; 1321 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1322 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1323 // Phase 3, inputs and outputs 1324 model->identifyInputsAndOutputs( 1325 {scores3, roi3, anchors3}, 1326 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1327 // Phase 4: set relaxed execution 1328 model->relaxComputationFloat32toFloat16(true); 1329 assert(model->isValid()); 1330 } 1331 1332 inline bool is_ignored_relaxed_3(int i) { 1333 static std::set<int> ignore = {}; 1334 return ignore.find(i) != ignore.end(); 1335 } 1336 1337 void CreateModel_float16_3(Model *model) { 1338 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 1339 OperandType type12(Type::FLOAT16, {}); 1340 OperandType type14(Type::TENSOR_FLOAT16, {1, 3, 4}); 1341 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 1342 OperandType type16(Type::TENSOR_FLOAT16, {1, 3}); 1343 OperandType type23(Type::TENSOR_FLOAT16, {1, 6, 7}); 1344 OperandType type5(Type::TENSOR_INT32, {1, 3}); 1345 OperandType type6(Type::TENSOR_INT32, {1}); 1346 OperandType type8(Type::BOOL, {}); 1347 OperandType type9(Type::INT32, {}); 1348 // Phase 1, operands 1349 auto scores3 = model->addOperand(&type15); 1350 auto roi3 = model->addOperand(&type23); 1351 auto anchors3 = model->addOperand(&type11); 1352 auto param33 = model->addOperand(&type12); 1353 auto param34 = model->addOperand(&type12); 1354 auto param35 = model->addOperand(&type12); 1355 auto param36 = model->addOperand(&type12); 1356 auto param37 = model->addOperand(&type8); 1357 auto param38 = model->addOperand(&type9); 1358 auto param39 = model->addOperand(&type9); 1359 auto param40 = model->addOperand(&type9); 1360 auto param41 = model->addOperand(&type12); 1361 auto param42 = model->addOperand(&type12); 1362 auto param43 = model->addOperand(&type8); 1363 auto scoresOut3 = model->addOperand(&type16); 1364 auto roiOut3 = model->addOperand(&type14); 1365 auto classesOut3 = model->addOperand(&type5); 1366 auto detectionOut3 = model->addOperand(&type6); 1367 // Phase 2, operations 1368 static _Float16 param33_init[] = {10.0f}; 1369 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1); 1370 static _Float16 param34_init[] = {10.0f}; 1371 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1); 1372 static _Float16 param35_init[] = {5.0f}; 1373 model->setOperandValue(param35, param35_init, sizeof(_Float16) * 1); 1374 static _Float16 param36_init[] = {5.0f}; 1375 model->setOperandValue(param36, param36_init, sizeof(_Float16) * 1); 1376 static bool8 param37_init[] = {false}; 1377 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1378 static int32_t param38_init[] = {3}; 1379 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1380 static int32_t param39_init[] = {1}; 1381 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1382 static int32_t param40_init[] = {1}; 1383 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1384 static _Float16 param41_init[] = {0.0f}; 1385 model->setOperandValue(param41, param41_init, sizeof(_Float16) * 1); 1386 static _Float16 param42_init[] = {0.5f}; 1387 model->setOperandValue(param42, param42_init, sizeof(_Float16) * 1); 1388 static bool8 param43_init[] = {true}; 1389 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1390 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1391 // Phase 3, inputs and outputs 1392 model->identifyInputsAndOutputs( 1393 {scores3, roi3, anchors3}, 1394 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1395 assert(model->isValid()); 1396 } 1397 1398 inline bool is_ignored_float16_3(int i) { 1399 static std::set<int> ignore = {}; 1400 return ignore.find(i) != ignore.end(); 1401 } 1402 1403 void CreateModel_dynamic_output_shape_3(Model *model) { 1404 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1405 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1406 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 1407 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 1408 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1409 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1410 OperandType type20(Type::TENSOR_INT32, {0}); 1411 OperandType type7(Type::FLOAT32, {}); 1412 OperandType type8(Type::BOOL, {}); 1413 OperandType type9(Type::INT32, {}); 1414 // Phase 1, operands 1415 auto scores3 = model->addOperand(&type0); 1416 auto roi3 = model->addOperand(&type10); 1417 auto anchors3 = model->addOperand(&type2); 1418 auto param33 = model->addOperand(&type7); 1419 auto param34 = model->addOperand(&type7); 1420 auto param35 = model->addOperand(&type7); 1421 auto param36 = model->addOperand(&type7); 1422 auto param37 = model->addOperand(&type8); 1423 auto param38 = model->addOperand(&type9); 1424 auto param39 = model->addOperand(&type9); 1425 auto param40 = model->addOperand(&type9); 1426 auto param41 = model->addOperand(&type7); 1427 auto param42 = model->addOperand(&type7); 1428 auto param43 = model->addOperand(&type8); 1429 auto scoresOut3 = model->addOperand(&type17); 1430 auto roiOut3 = model->addOperand(&type18); 1431 auto classesOut3 = model->addOperand(&type19); 1432 auto detectionOut3 = model->addOperand(&type20); 1433 // Phase 2, operations 1434 static float param33_init[] = {10.0f}; 1435 model->setOperandValue(param33, param33_init, sizeof(float) * 1); 1436 static float param34_init[] = {10.0f}; 1437 model->setOperandValue(param34, param34_init, sizeof(float) * 1); 1438 static float param35_init[] = {5.0f}; 1439 model->setOperandValue(param35, param35_init, sizeof(float) * 1); 1440 static float param36_init[] = {5.0f}; 1441 model->setOperandValue(param36, param36_init, sizeof(float) * 1); 1442 static bool8 param37_init[] = {false}; 1443 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1444 static int32_t param38_init[] = {3}; 1445 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1446 static int32_t param39_init[] = {1}; 1447 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1448 static int32_t param40_init[] = {1}; 1449 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1450 static float param41_init[] = {0.0f}; 1451 model->setOperandValue(param41, param41_init, sizeof(float) * 1); 1452 static float param42_init[] = {0.5f}; 1453 model->setOperandValue(param42, param42_init, sizeof(float) * 1); 1454 static bool8 param43_init[] = {true}; 1455 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1456 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1457 // Phase 3, inputs and outputs 1458 model->identifyInputsAndOutputs( 1459 {scores3, roi3, anchors3}, 1460 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1461 assert(model->isValid()); 1462 } 1463 1464 inline bool is_ignored_dynamic_output_shape_3(int i) { 1465 static std::set<int> ignore = {}; 1466 return ignore.find(i) != ignore.end(); 1467 } 1468 1469 void CreateModel_dynamic_output_shape_relaxed_3(Model *model) { 1470 OperandType type0(Type::TENSOR_FLOAT32, {1, 6, 3}); 1471 OperandType type10(Type::TENSOR_FLOAT32, {1, 6, 7}); 1472 OperandType type17(Type::TENSOR_FLOAT32, {0, 0}); 1473 OperandType type18(Type::TENSOR_FLOAT32, {0, 0, 0}); 1474 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1475 OperandType type2(Type::TENSOR_FLOAT32, {6, 4}); 1476 OperandType type20(Type::TENSOR_INT32, {0}); 1477 OperandType type7(Type::FLOAT32, {}); 1478 OperandType type8(Type::BOOL, {}); 1479 OperandType type9(Type::INT32, {}); 1480 // Phase 1, operands 1481 auto scores3 = model->addOperand(&type0); 1482 auto roi3 = model->addOperand(&type10); 1483 auto anchors3 = model->addOperand(&type2); 1484 auto param33 = model->addOperand(&type7); 1485 auto param34 = model->addOperand(&type7); 1486 auto param35 = model->addOperand(&type7); 1487 auto param36 = model->addOperand(&type7); 1488 auto param37 = model->addOperand(&type8); 1489 auto param38 = model->addOperand(&type9); 1490 auto param39 = model->addOperand(&type9); 1491 auto param40 = model->addOperand(&type9); 1492 auto param41 = model->addOperand(&type7); 1493 auto param42 = model->addOperand(&type7); 1494 auto param43 = model->addOperand(&type8); 1495 auto scoresOut3 = model->addOperand(&type17); 1496 auto roiOut3 = model->addOperand(&type18); 1497 auto classesOut3 = model->addOperand(&type19); 1498 auto detectionOut3 = model->addOperand(&type20); 1499 // Phase 2, operations 1500 static float param33_init[] = {10.0f}; 1501 model->setOperandValue(param33, param33_init, sizeof(float) * 1); 1502 static float param34_init[] = {10.0f}; 1503 model->setOperandValue(param34, param34_init, sizeof(float) * 1); 1504 static float param35_init[] = {5.0f}; 1505 model->setOperandValue(param35, param35_init, sizeof(float) * 1); 1506 static float param36_init[] = {5.0f}; 1507 model->setOperandValue(param36, param36_init, sizeof(float) * 1); 1508 static bool8 param37_init[] = {false}; 1509 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1510 static int32_t param38_init[] = {3}; 1511 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1512 static int32_t param39_init[] = {1}; 1513 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1514 static int32_t param40_init[] = {1}; 1515 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1516 static float param41_init[] = {0.0f}; 1517 model->setOperandValue(param41, param41_init, sizeof(float) * 1); 1518 static float param42_init[] = {0.5f}; 1519 model->setOperandValue(param42, param42_init, sizeof(float) * 1); 1520 static bool8 param43_init[] = {true}; 1521 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1522 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1523 // Phase 3, inputs and outputs 1524 model->identifyInputsAndOutputs( 1525 {scores3, roi3, anchors3}, 1526 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1527 // Phase 4: set relaxed execution 1528 model->relaxComputationFloat32toFloat16(true); 1529 assert(model->isValid()); 1530 } 1531 1532 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) { 1533 static std::set<int> ignore = {}; 1534 return ignore.find(i) != ignore.end(); 1535 } 1536 1537 void CreateModel_dynamic_output_shape_float16_3(Model *model) { 1538 OperandType type11(Type::TENSOR_FLOAT16, {6, 4}); 1539 OperandType type12(Type::FLOAT16, {}); 1540 OperandType type15(Type::TENSOR_FLOAT16, {1, 6, 3}); 1541 OperandType type19(Type::TENSOR_INT32, {0, 0}); 1542 OperandType type20(Type::TENSOR_INT32, {0}); 1543 OperandType type21(Type::TENSOR_FLOAT16, {0, 0}); 1544 OperandType type22(Type::TENSOR_FLOAT16, {0, 0, 0}); 1545 OperandType type23(Type::TENSOR_FLOAT16, {1, 6, 7}); 1546 OperandType type8(Type::BOOL, {}); 1547 OperandType type9(Type::INT32, {}); 1548 // Phase 1, operands 1549 auto scores3 = model->addOperand(&type15); 1550 auto roi3 = model->addOperand(&type23); 1551 auto anchors3 = model->addOperand(&type11); 1552 auto param33 = model->addOperand(&type12); 1553 auto param34 = model->addOperand(&type12); 1554 auto param35 = model->addOperand(&type12); 1555 auto param36 = model->addOperand(&type12); 1556 auto param37 = model->addOperand(&type8); 1557 auto param38 = model->addOperand(&type9); 1558 auto param39 = model->addOperand(&type9); 1559 auto param40 = model->addOperand(&type9); 1560 auto param41 = model->addOperand(&type12); 1561 auto param42 = model->addOperand(&type12); 1562 auto param43 = model->addOperand(&type8); 1563 auto scoresOut3 = model->addOperand(&type21); 1564 auto roiOut3 = model->addOperand(&type22); 1565 auto classesOut3 = model->addOperand(&type19); 1566 auto detectionOut3 = model->addOperand(&type20); 1567 // Phase 2, operations 1568 static _Float16 param33_init[] = {10.0f}; 1569 model->setOperandValue(param33, param33_init, sizeof(_Float16) * 1); 1570 static _Float16 param34_init[] = {10.0f}; 1571 model->setOperandValue(param34, param34_init, sizeof(_Float16) * 1); 1572 static _Float16 param35_init[] = {5.0f}; 1573 model->setOperandValue(param35, param35_init, sizeof(_Float16) * 1); 1574 static _Float16 param36_init[] = {5.0f}; 1575 model->setOperandValue(param36, param36_init, sizeof(_Float16) * 1); 1576 static bool8 param37_init[] = {false}; 1577 model->setOperandValue(param37, param37_init, sizeof(bool8) * 1); 1578 static int32_t param38_init[] = {3}; 1579 model->setOperandValue(param38, param38_init, sizeof(int32_t) * 1); 1580 static int32_t param39_init[] = {1}; 1581 model->setOperandValue(param39, param39_init, sizeof(int32_t) * 1); 1582 static int32_t param40_init[] = {1}; 1583 model->setOperandValue(param40, param40_init, sizeof(int32_t) * 1); 1584 static _Float16 param41_init[] = {0.0f}; 1585 model->setOperandValue(param41, param41_init, sizeof(_Float16) * 1); 1586 static _Float16 param42_init[] = {0.5f}; 1587 model->setOperandValue(param42, param42_init, sizeof(_Float16) * 1); 1588 static bool8 param43_init[] = {true}; 1589 model->setOperandValue(param43, param43_init, sizeof(bool8) * 1); 1590 model->addOperation(ANEURALNETWORKS_DETECTION_POSTPROCESSING, {scores3, roi3, anchors3, param33, param34, param35, param36, param37, param38, param39, param40, param41, param42, param43}, {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1591 // Phase 3, inputs and outputs 1592 model->identifyInputsAndOutputs( 1593 {scores3, roi3, anchors3}, 1594 {scoresOut3, roiOut3, classesOut3, detectionOut3}); 1595 assert(model->isValid()); 1596 } 1597 1598 inline bool is_ignored_dynamic_output_shape_float16_3(int i) { 1599 static std::set<int> ignore = {}; 1600 return ignore.find(i) != ignore.end(); 1601 } 1602 1603
