1 // clang-format off 2 // Generated file (from: conv2d_dilation.mod.py). Do not edit 3 void CreateModel_nhwc(Model *model) { 4 OperandType type0(Type::BOOL, {}); 5 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7 OperandType type3(Type::TENSOR_FLOAT32, {1}); 8 OperandType type4(Type::INT32, {}); 9 // Phase 1, operands 10 auto op1 = model->addOperand(&type1); 11 auto op2 = model->addOperand(&type2); 12 auto op3 = model->addOperand(&type3); 13 auto param = model->addOperand(&type4); 14 auto param1 = model->addOperand(&type4); 15 auto param2 = model->addOperand(&type4); 16 auto param3 = model->addOperand(&type4); 17 auto param4 = model->addOperand(&type4); 18 auto param5 = model->addOperand(&type4); 19 auto param6 = model->addOperand(&type4); 20 auto layout = model->addOperand(&type0); 21 auto param7 = model->addOperand(&type4); 22 auto param8 = model->addOperand(&type4); 23 auto op4 = model->addOperand(&type2); 24 // Phase 2, operations 25 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 26 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 27 static float op3_init[] = {0.0f}; 28 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 29 static int32_t param_init[] = {0}; 30 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 31 static int32_t param1_init[] = {0}; 32 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 33 static int32_t param2_init[] = {0}; 34 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 35 static int32_t param3_init[] = {0}; 36 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 37 static int32_t param4_init[] = {1}; 38 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 39 static int32_t param5_init[] = {1}; 40 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 41 static int32_t param6_init[] = {0}; 42 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 43 static bool8 layout_init[] = {false}; 44 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 45 static int32_t param7_init[] = {1}; 46 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 47 static int32_t param8_init[] = {1}; 48 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 49 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 50 // Phase 3, inputs and outputs 51 model->identifyInputsAndOutputs( 52 {op1}, 53 {op4}); 54 assert(model->isValid()); 55 } 56 57 inline bool is_ignored_nhwc(int i) { 58 static std::set<int> ignore = {}; 59 return ignore.find(i) != ignore.end(); 60 } 61 62 void CreateModel_nhwc_relaxed(Model *model) { 63 OperandType type0(Type::BOOL, {}); 64 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 65 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 66 OperandType type3(Type::TENSOR_FLOAT32, {1}); 67 OperandType type4(Type::INT32, {}); 68 // Phase 1, operands 69 auto op1 = model->addOperand(&type1); 70 auto op2 = model->addOperand(&type2); 71 auto op3 = model->addOperand(&type3); 72 auto param = model->addOperand(&type4); 73 auto param1 = model->addOperand(&type4); 74 auto param2 = model->addOperand(&type4); 75 auto param3 = model->addOperand(&type4); 76 auto param4 = model->addOperand(&type4); 77 auto param5 = model->addOperand(&type4); 78 auto param6 = model->addOperand(&type4); 79 auto layout = model->addOperand(&type0); 80 auto param7 = model->addOperand(&type4); 81 auto param8 = model->addOperand(&type4); 82 auto op4 = model->addOperand(&type2); 83 // Phase 2, operations 84 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 85 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 86 static float op3_init[] = {0.0f}; 87 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 88 static int32_t param_init[] = {0}; 89 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 90 static int32_t param1_init[] = {0}; 91 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 92 static int32_t param2_init[] = {0}; 93 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 94 static int32_t param3_init[] = {0}; 95 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 96 static int32_t param4_init[] = {1}; 97 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 98 static int32_t param5_init[] = {1}; 99 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 100 static int32_t param6_init[] = {0}; 101 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 102 static bool8 layout_init[] = {false}; 103 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 104 static int32_t param7_init[] = {1}; 105 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 106 static int32_t param8_init[] = {1}; 107 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 108 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 109 // Phase 3, inputs and outputs 110 model->identifyInputsAndOutputs( 111 {op1}, 112 {op4}); 113 // Phase 4: set relaxed execution 114 model->relaxComputationFloat32toFloat16(true); 115 assert(model->isValid()); 116 } 117 118 inline bool is_ignored_nhwc_relaxed(int i) { 119 static std::set<int> ignore = {}; 120 return ignore.find(i) != ignore.end(); 121 } 122 123 void CreateModel_nhwc_quant8(Model *model) { 124 OperandType type0(Type::BOOL, {}); 125 OperandType type4(Type::INT32, {}); 126 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 127 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 128 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 129 // Phase 1, operands 130 auto op1 = model->addOperand(&type7); 131 auto op2 = model->addOperand(&type8); 132 auto op3 = model->addOperand(&type9); 133 auto param = model->addOperand(&type4); 134 auto param1 = model->addOperand(&type4); 135 auto param2 = model->addOperand(&type4); 136 auto param3 = model->addOperand(&type4); 137 auto param4 = model->addOperand(&type4); 138 auto param5 = model->addOperand(&type4); 139 auto param6 = model->addOperand(&type4); 140 auto layout = model->addOperand(&type0); 141 auto param7 = model->addOperand(&type4); 142 auto param8 = model->addOperand(&type4); 143 auto op4 = model->addOperand(&type8); 144 // Phase 2, operations 145 static uint8_t op2_init[] = {2, 2, 2, 2}; 146 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 4); 147 static int32_t op3_init[] = {0}; 148 model->setOperandValue(op3, op3_init, sizeof(int32_t) * 1); 149 static int32_t param_init[] = {0}; 150 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 151 static int32_t param1_init[] = {0}; 152 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 153 static int32_t param2_init[] = {0}; 154 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 155 static int32_t param3_init[] = {0}; 156 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 157 static int32_t param4_init[] = {1}; 158 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 159 static int32_t param5_init[] = {1}; 160 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 161 static int32_t param6_init[] = {0}; 162 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 163 static bool8 layout_init[] = {false}; 164 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 165 static int32_t param7_init[] = {1}; 166 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 167 static int32_t param8_init[] = {1}; 168 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 169 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 170 // Phase 3, inputs and outputs 171 model->identifyInputsAndOutputs( 172 {op1}, 173 {op4}); 174 assert(model->isValid()); 175 } 176 177 inline bool is_ignored_nhwc_quant8(int i) { 178 static std::set<int> ignore = {}; 179 return ignore.find(i) != ignore.end(); 180 } 181 182 void CreateModel_nhwc_float16(Model *model) { 183 OperandType type0(Type::BOOL, {}); 184 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 185 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 186 OperandType type12(Type::TENSOR_FLOAT16, {1}); 187 OperandType type4(Type::INT32, {}); 188 // Phase 1, operands 189 auto op1 = model->addOperand(&type10); 190 auto op2 = model->addOperand(&type11); 191 auto op3 = model->addOperand(&type12); 192 auto param = model->addOperand(&type4); 193 auto param1 = model->addOperand(&type4); 194 auto param2 = model->addOperand(&type4); 195 auto param3 = model->addOperand(&type4); 196 auto param4 = model->addOperand(&type4); 197 auto param5 = model->addOperand(&type4); 198 auto param6 = model->addOperand(&type4); 199 auto layout = model->addOperand(&type0); 200 auto param7 = model->addOperand(&type4); 201 auto param8 = model->addOperand(&type4); 202 auto op4 = model->addOperand(&type11); 203 // Phase 2, operations 204 static _Float16 op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 205 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 4); 206 static _Float16 op3_init[] = {0.0f}; 207 model->setOperandValue(op3, op3_init, sizeof(_Float16) * 1); 208 static int32_t param_init[] = {0}; 209 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 210 static int32_t param1_init[] = {0}; 211 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 212 static int32_t param2_init[] = {0}; 213 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 214 static int32_t param3_init[] = {0}; 215 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 216 static int32_t param4_init[] = {1}; 217 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 218 static int32_t param5_init[] = {1}; 219 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 220 static int32_t param6_init[] = {0}; 221 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 222 static bool8 layout_init[] = {false}; 223 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 224 static int32_t param7_init[] = {1}; 225 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 226 static int32_t param8_init[] = {1}; 227 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 228 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 229 // Phase 3, inputs and outputs 230 model->identifyInputsAndOutputs( 231 {op1}, 232 {op4}); 233 assert(model->isValid()); 234 } 235 236 inline bool is_ignored_nhwc_float16(int i) { 237 static std::set<int> ignore = {}; 238 return ignore.find(i) != ignore.end(); 239 } 240 241 void CreateModel_nhwc_weight_as_input(Model *model) { 242 OperandType type0(Type::BOOL, {}); 243 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 244 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 245 OperandType type3(Type::TENSOR_FLOAT32, {1}); 246 OperandType type4(Type::INT32, {}); 247 // Phase 1, operands 248 auto op1 = model->addOperand(&type1); 249 auto op2 = model->addOperand(&type2); 250 auto op3 = model->addOperand(&type3); 251 auto param = model->addOperand(&type4); 252 auto param1 = model->addOperand(&type4); 253 auto param2 = model->addOperand(&type4); 254 auto param3 = model->addOperand(&type4); 255 auto param4 = model->addOperand(&type4); 256 auto param5 = model->addOperand(&type4); 257 auto param6 = model->addOperand(&type4); 258 auto layout = model->addOperand(&type0); 259 auto param7 = model->addOperand(&type4); 260 auto param8 = model->addOperand(&type4); 261 auto op4 = model->addOperand(&type2); 262 // Phase 2, operations 263 static int32_t param_init[] = {0}; 264 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 265 static int32_t param1_init[] = {0}; 266 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 267 static int32_t param2_init[] = {0}; 268 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 269 static int32_t param3_init[] = {0}; 270 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 271 static int32_t param4_init[] = {1}; 272 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 273 static int32_t param5_init[] = {1}; 274 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 275 static int32_t param6_init[] = {0}; 276 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 277 static bool8 layout_init[] = {false}; 278 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 279 static int32_t param7_init[] = {1}; 280 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 281 static int32_t param8_init[] = {1}; 282 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 283 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 284 // Phase 3, inputs and outputs 285 model->identifyInputsAndOutputs( 286 {op1, op2, op3}, 287 {op4}); 288 assert(model->isValid()); 289 } 290 291 inline bool is_ignored_nhwc_weight_as_input(int i) { 292 static std::set<int> ignore = {}; 293 return ignore.find(i) != ignore.end(); 294 } 295 296 void CreateModel_nhwc_weight_as_input_relaxed(Model *model) { 297 OperandType type0(Type::BOOL, {}); 298 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 299 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 300 OperandType type3(Type::TENSOR_FLOAT32, {1}); 301 OperandType type4(Type::INT32, {}); 302 // Phase 1, operands 303 auto op1 = model->addOperand(&type1); 304 auto op2 = model->addOperand(&type2); 305 auto op3 = model->addOperand(&type3); 306 auto param = model->addOperand(&type4); 307 auto param1 = model->addOperand(&type4); 308 auto param2 = model->addOperand(&type4); 309 auto param3 = model->addOperand(&type4); 310 auto param4 = model->addOperand(&type4); 311 auto param5 = model->addOperand(&type4); 312 auto param6 = model->addOperand(&type4); 313 auto layout = model->addOperand(&type0); 314 auto param7 = model->addOperand(&type4); 315 auto param8 = model->addOperand(&type4); 316 auto op4 = model->addOperand(&type2); 317 // Phase 2, operations 318 static int32_t param_init[] = {0}; 319 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 320 static int32_t param1_init[] = {0}; 321 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 322 static int32_t param2_init[] = {0}; 323 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 324 static int32_t param3_init[] = {0}; 325 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 326 static int32_t param4_init[] = {1}; 327 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 328 static int32_t param5_init[] = {1}; 329 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 330 static int32_t param6_init[] = {0}; 331 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 332 static bool8 layout_init[] = {false}; 333 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 334 static int32_t param7_init[] = {1}; 335 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 336 static int32_t param8_init[] = {1}; 337 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 338 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 339 // Phase 3, inputs and outputs 340 model->identifyInputsAndOutputs( 341 {op1, op2, op3}, 342 {op4}); 343 // Phase 4: set relaxed execution 344 model->relaxComputationFloat32toFloat16(true); 345 assert(model->isValid()); 346 } 347 348 inline bool is_ignored_nhwc_weight_as_input_relaxed(int i) { 349 static std::set<int> ignore = {}; 350 return ignore.find(i) != ignore.end(); 351 } 352 353 void CreateModel_nhwc_weight_as_input_quant8(Model *model) { 354 OperandType type0(Type::BOOL, {}); 355 OperandType type4(Type::INT32, {}); 356 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 357 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 358 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 359 // Phase 1, operands 360 auto op1 = model->addOperand(&type7); 361 auto op2 = model->addOperand(&type8); 362 auto op3 = model->addOperand(&type9); 363 auto param = model->addOperand(&type4); 364 auto param1 = model->addOperand(&type4); 365 auto param2 = model->addOperand(&type4); 366 auto param3 = model->addOperand(&type4); 367 auto param4 = model->addOperand(&type4); 368 auto param5 = model->addOperand(&type4); 369 auto param6 = model->addOperand(&type4); 370 auto layout = model->addOperand(&type0); 371 auto param7 = model->addOperand(&type4); 372 auto param8 = model->addOperand(&type4); 373 auto op4 = model->addOperand(&type8); 374 // Phase 2, operations 375 static int32_t param_init[] = {0}; 376 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 377 static int32_t param1_init[] = {0}; 378 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 379 static int32_t param2_init[] = {0}; 380 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 381 static int32_t param3_init[] = {0}; 382 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 383 static int32_t param4_init[] = {1}; 384 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 385 static int32_t param5_init[] = {1}; 386 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 387 static int32_t param6_init[] = {0}; 388 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 389 static bool8 layout_init[] = {false}; 390 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 391 static int32_t param7_init[] = {1}; 392 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 393 static int32_t param8_init[] = {1}; 394 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 395 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 396 // Phase 3, inputs and outputs 397 model->identifyInputsAndOutputs( 398 {op1, op2, op3}, 399 {op4}); 400 assert(model->isValid()); 401 } 402 403 inline bool is_ignored_nhwc_weight_as_input_quant8(int i) { 404 static std::set<int> ignore = {}; 405 return ignore.find(i) != ignore.end(); 406 } 407 408 void CreateModel_nhwc_weight_as_input_float16(Model *model) { 409 OperandType type0(Type::BOOL, {}); 410 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 411 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 412 OperandType type12(Type::TENSOR_FLOAT16, {1}); 413 OperandType type4(Type::INT32, {}); 414 // Phase 1, operands 415 auto op1 = model->addOperand(&type10); 416 auto op2 = model->addOperand(&type11); 417 auto op3 = model->addOperand(&type12); 418 auto param = model->addOperand(&type4); 419 auto param1 = model->addOperand(&type4); 420 auto param2 = model->addOperand(&type4); 421 auto param3 = model->addOperand(&type4); 422 auto param4 = model->addOperand(&type4); 423 auto param5 = model->addOperand(&type4); 424 auto param6 = model->addOperand(&type4); 425 auto layout = model->addOperand(&type0); 426 auto param7 = model->addOperand(&type4); 427 auto param8 = model->addOperand(&type4); 428 auto op4 = model->addOperand(&type11); 429 // Phase 2, operations 430 static int32_t param_init[] = {0}; 431 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 432 static int32_t param1_init[] = {0}; 433 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 434 static int32_t param2_init[] = {0}; 435 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 436 static int32_t param3_init[] = {0}; 437 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 438 static int32_t param4_init[] = {1}; 439 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 440 static int32_t param5_init[] = {1}; 441 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 442 static int32_t param6_init[] = {0}; 443 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 444 static bool8 layout_init[] = {false}; 445 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 446 static int32_t param7_init[] = {1}; 447 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 448 static int32_t param8_init[] = {1}; 449 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 450 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 451 // Phase 3, inputs and outputs 452 model->identifyInputsAndOutputs( 453 {op1, op2, op3}, 454 {op4}); 455 assert(model->isValid()); 456 } 457 458 inline bool is_ignored_nhwc_weight_as_input_float16(int i) { 459 static std::set<int> ignore = {}; 460 return ignore.find(i) != ignore.end(); 461 } 462 463 void CreateModel_nchw(Model *model) { 464 OperandType type0(Type::BOOL, {}); 465 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 466 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 467 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 468 OperandType type3(Type::TENSOR_FLOAT32, {1}); 469 OperandType type4(Type::INT32, {}); 470 // Phase 1, operands 471 auto op1 = model->addOperand(&type13); 472 auto op2 = model->addOperand(&type2); 473 auto op3 = model->addOperand(&type3); 474 auto param = model->addOperand(&type4); 475 auto param1 = model->addOperand(&type4); 476 auto param2 = model->addOperand(&type4); 477 auto param3 = model->addOperand(&type4); 478 auto param4 = model->addOperand(&type4); 479 auto param5 = model->addOperand(&type4); 480 auto param6 = model->addOperand(&type4); 481 auto layout = model->addOperand(&type0); 482 auto param7 = model->addOperand(&type4); 483 auto param8 = model->addOperand(&type4); 484 auto op4 = model->addOperand(&type14); 485 // Phase 2, operations 486 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 487 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 488 static float op3_init[] = {0.0f}; 489 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 490 static int32_t param_init[] = {0}; 491 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 492 static int32_t param1_init[] = {0}; 493 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 494 static int32_t param2_init[] = {0}; 495 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 496 static int32_t param3_init[] = {0}; 497 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 498 static int32_t param4_init[] = {1}; 499 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 500 static int32_t param5_init[] = {1}; 501 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 502 static int32_t param6_init[] = {0}; 503 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 504 static bool8 layout_init[] = {true}; 505 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 506 static int32_t param7_init[] = {1}; 507 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 508 static int32_t param8_init[] = {1}; 509 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 510 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 511 // Phase 3, inputs and outputs 512 model->identifyInputsAndOutputs( 513 {op1}, 514 {op4}); 515 assert(model->isValid()); 516 } 517 518 inline bool is_ignored_nchw(int i) { 519 static std::set<int> ignore = {}; 520 return ignore.find(i) != ignore.end(); 521 } 522 523 void CreateModel_nchw_relaxed(Model *model) { 524 OperandType type0(Type::BOOL, {}); 525 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 526 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 527 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 528 OperandType type3(Type::TENSOR_FLOAT32, {1}); 529 OperandType type4(Type::INT32, {}); 530 // Phase 1, operands 531 auto op1 = model->addOperand(&type13); 532 auto op2 = model->addOperand(&type2); 533 auto op3 = model->addOperand(&type3); 534 auto param = model->addOperand(&type4); 535 auto param1 = model->addOperand(&type4); 536 auto param2 = model->addOperand(&type4); 537 auto param3 = model->addOperand(&type4); 538 auto param4 = model->addOperand(&type4); 539 auto param5 = model->addOperand(&type4); 540 auto param6 = model->addOperand(&type4); 541 auto layout = model->addOperand(&type0); 542 auto param7 = model->addOperand(&type4); 543 auto param8 = model->addOperand(&type4); 544 auto op4 = model->addOperand(&type14); 545 // Phase 2, operations 546 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 547 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 548 static float op3_init[] = {0.0f}; 549 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 550 static int32_t param_init[] = {0}; 551 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 552 static int32_t param1_init[] = {0}; 553 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 554 static int32_t param2_init[] = {0}; 555 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 556 static int32_t param3_init[] = {0}; 557 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 558 static int32_t param4_init[] = {1}; 559 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 560 static int32_t param5_init[] = {1}; 561 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 562 static int32_t param6_init[] = {0}; 563 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 564 static bool8 layout_init[] = {true}; 565 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 566 static int32_t param7_init[] = {1}; 567 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 568 static int32_t param8_init[] = {1}; 569 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 570 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 571 // Phase 3, inputs and outputs 572 model->identifyInputsAndOutputs( 573 {op1}, 574 {op4}); 575 // Phase 4: set relaxed execution 576 model->relaxComputationFloat32toFloat16(true); 577 assert(model->isValid()); 578 } 579 580 inline bool is_ignored_nchw_relaxed(int i) { 581 static std::set<int> ignore = {}; 582 return ignore.find(i) != ignore.end(); 583 } 584 585 void CreateModel_nchw_quant8(Model *model) { 586 OperandType type0(Type::BOOL, {}); 587 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 588 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {1, 1, 2, 2}, 0.125f, 0); 589 OperandType type4(Type::INT32, {}); 590 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 591 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 592 // Phase 1, operands 593 auto op1 = model->addOperand(&type15); 594 auto op2 = model->addOperand(&type8); 595 auto op3 = model->addOperand(&type9); 596 auto param = model->addOperand(&type4); 597 auto param1 = model->addOperand(&type4); 598 auto param2 = model->addOperand(&type4); 599 auto param3 = model->addOperand(&type4); 600 auto param4 = model->addOperand(&type4); 601 auto param5 = model->addOperand(&type4); 602 auto param6 = model->addOperand(&type4); 603 auto layout = model->addOperand(&type0); 604 auto param7 = model->addOperand(&type4); 605 auto param8 = model->addOperand(&type4); 606 auto op4 = model->addOperand(&type16); 607 // Phase 2, operations 608 static uint8_t op2_init[] = {2, 2, 2, 2}; 609 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 4); 610 static int32_t op3_init[] = {0}; 611 model->setOperandValue(op3, op3_init, sizeof(int32_t) * 1); 612 static int32_t param_init[] = {0}; 613 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 614 static int32_t param1_init[] = {0}; 615 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 616 static int32_t param2_init[] = {0}; 617 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 618 static int32_t param3_init[] = {0}; 619 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 620 static int32_t param4_init[] = {1}; 621 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 622 static int32_t param5_init[] = {1}; 623 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 624 static int32_t param6_init[] = {0}; 625 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 626 static bool8 layout_init[] = {true}; 627 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 628 static int32_t param7_init[] = {1}; 629 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 630 static int32_t param8_init[] = {1}; 631 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 632 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 633 // Phase 3, inputs and outputs 634 model->identifyInputsAndOutputs( 635 {op1}, 636 {op4}); 637 assert(model->isValid()); 638 } 639 640 inline bool is_ignored_nchw_quant8(int i) { 641 static std::set<int> ignore = {}; 642 return ignore.find(i) != ignore.end(); 643 } 644 645 void CreateModel_nchw_float16(Model *model) { 646 OperandType type0(Type::BOOL, {}); 647 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 648 OperandType type12(Type::TENSOR_FLOAT16, {1}); 649 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 650 OperandType type18(Type::TENSOR_FLOAT16, {1, 1, 2, 2}); 651 OperandType type4(Type::INT32, {}); 652 // Phase 1, operands 653 auto op1 = model->addOperand(&type17); 654 auto op2 = model->addOperand(&type11); 655 auto op3 = model->addOperand(&type12); 656 auto param = model->addOperand(&type4); 657 auto param1 = model->addOperand(&type4); 658 auto param2 = model->addOperand(&type4); 659 auto param3 = model->addOperand(&type4); 660 auto param4 = model->addOperand(&type4); 661 auto param5 = model->addOperand(&type4); 662 auto param6 = model->addOperand(&type4); 663 auto layout = model->addOperand(&type0); 664 auto param7 = model->addOperand(&type4); 665 auto param8 = model->addOperand(&type4); 666 auto op4 = model->addOperand(&type18); 667 // Phase 2, operations 668 static _Float16 op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 669 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 4); 670 static _Float16 op3_init[] = {0.0f}; 671 model->setOperandValue(op3, op3_init, sizeof(_Float16) * 1); 672 static int32_t param_init[] = {0}; 673 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 674 static int32_t param1_init[] = {0}; 675 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 676 static int32_t param2_init[] = {0}; 677 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 678 static int32_t param3_init[] = {0}; 679 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 680 static int32_t param4_init[] = {1}; 681 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 682 static int32_t param5_init[] = {1}; 683 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 684 static int32_t param6_init[] = {0}; 685 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 686 static bool8 layout_init[] = {true}; 687 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 688 static int32_t param7_init[] = {1}; 689 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 690 static int32_t param8_init[] = {1}; 691 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 692 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 693 // Phase 3, inputs and outputs 694 model->identifyInputsAndOutputs( 695 {op1}, 696 {op4}); 697 assert(model->isValid()); 698 } 699 700 inline bool is_ignored_nchw_float16(int i) { 701 static std::set<int> ignore = {}; 702 return ignore.find(i) != ignore.end(); 703 } 704 705 void CreateModel_nchw_weight_as_input(Model *model) { 706 OperandType type0(Type::BOOL, {}); 707 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 708 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 709 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 710 OperandType type3(Type::TENSOR_FLOAT32, {1}); 711 OperandType type4(Type::INT32, {}); 712 // Phase 1, operands 713 auto op1 = model->addOperand(&type13); 714 auto op2 = model->addOperand(&type2); 715 auto op3 = model->addOperand(&type3); 716 auto param = model->addOperand(&type4); 717 auto param1 = model->addOperand(&type4); 718 auto param2 = model->addOperand(&type4); 719 auto param3 = model->addOperand(&type4); 720 auto param4 = model->addOperand(&type4); 721 auto param5 = model->addOperand(&type4); 722 auto param6 = model->addOperand(&type4); 723 auto layout = model->addOperand(&type0); 724 auto param7 = model->addOperand(&type4); 725 auto param8 = model->addOperand(&type4); 726 auto op4 = model->addOperand(&type14); 727 // Phase 2, operations 728 static int32_t param_init[] = {0}; 729 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 730 static int32_t param1_init[] = {0}; 731 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 732 static int32_t param2_init[] = {0}; 733 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 734 static int32_t param3_init[] = {0}; 735 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 736 static int32_t param4_init[] = {1}; 737 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 738 static int32_t param5_init[] = {1}; 739 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 740 static int32_t param6_init[] = {0}; 741 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 742 static bool8 layout_init[] = {true}; 743 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 744 static int32_t param7_init[] = {1}; 745 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 746 static int32_t param8_init[] = {1}; 747 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 748 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 749 // Phase 3, inputs and outputs 750 model->identifyInputsAndOutputs( 751 {op1, op2, op3}, 752 {op4}); 753 assert(model->isValid()); 754 } 755 756 inline bool is_ignored_nchw_weight_as_input(int i) { 757 static std::set<int> ignore = {}; 758 return ignore.find(i) != ignore.end(); 759 } 760 761 void CreateModel_nchw_weight_as_input_relaxed(Model *model) { 762 OperandType type0(Type::BOOL, {}); 763 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 764 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 765 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 766 OperandType type3(Type::TENSOR_FLOAT32, {1}); 767 OperandType type4(Type::INT32, {}); 768 // Phase 1, operands 769 auto op1 = model->addOperand(&type13); 770 auto op2 = model->addOperand(&type2); 771 auto op3 = model->addOperand(&type3); 772 auto param = model->addOperand(&type4); 773 auto param1 = model->addOperand(&type4); 774 auto param2 = model->addOperand(&type4); 775 auto param3 = model->addOperand(&type4); 776 auto param4 = model->addOperand(&type4); 777 auto param5 = model->addOperand(&type4); 778 auto param6 = model->addOperand(&type4); 779 auto layout = model->addOperand(&type0); 780 auto param7 = model->addOperand(&type4); 781 auto param8 = model->addOperand(&type4); 782 auto op4 = model->addOperand(&type14); 783 // Phase 2, operations 784 static int32_t param_init[] = {0}; 785 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 786 static int32_t param1_init[] = {0}; 787 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 788 static int32_t param2_init[] = {0}; 789 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 790 static int32_t param3_init[] = {0}; 791 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 792 static int32_t param4_init[] = {1}; 793 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 794 static int32_t param5_init[] = {1}; 795 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 796 static int32_t param6_init[] = {0}; 797 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 798 static bool8 layout_init[] = {true}; 799 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 800 static int32_t param7_init[] = {1}; 801 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 802 static int32_t param8_init[] = {1}; 803 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 804 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 805 // Phase 3, inputs and outputs 806 model->identifyInputsAndOutputs( 807 {op1, op2, op3}, 808 {op4}); 809 // Phase 4: set relaxed execution 810 model->relaxComputationFloat32toFloat16(true); 811 assert(model->isValid()); 812 } 813 814 inline bool is_ignored_nchw_weight_as_input_relaxed(int i) { 815 static std::set<int> ignore = {}; 816 return ignore.find(i) != ignore.end(); 817 } 818 819 void CreateModel_nchw_weight_as_input_quant8(Model *model) { 820 OperandType type0(Type::BOOL, {}); 821 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 822 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {1, 1, 2, 2}, 0.125f, 0); 823 OperandType type4(Type::INT32, {}); 824 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 825 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 826 // Phase 1, operands 827 auto op1 = model->addOperand(&type15); 828 auto op2 = model->addOperand(&type8); 829 auto op3 = model->addOperand(&type9); 830 auto param = model->addOperand(&type4); 831 auto param1 = model->addOperand(&type4); 832 auto param2 = model->addOperand(&type4); 833 auto param3 = model->addOperand(&type4); 834 auto param4 = model->addOperand(&type4); 835 auto param5 = model->addOperand(&type4); 836 auto param6 = model->addOperand(&type4); 837 auto layout = model->addOperand(&type0); 838 auto param7 = model->addOperand(&type4); 839 auto param8 = model->addOperand(&type4); 840 auto op4 = model->addOperand(&type16); 841 // Phase 2, operations 842 static int32_t param_init[] = {0}; 843 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 844 static int32_t param1_init[] = {0}; 845 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 846 static int32_t param2_init[] = {0}; 847 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 848 static int32_t param3_init[] = {0}; 849 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 850 static int32_t param4_init[] = {1}; 851 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 852 static int32_t param5_init[] = {1}; 853 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 854 static int32_t param6_init[] = {0}; 855 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 856 static bool8 layout_init[] = {true}; 857 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 858 static int32_t param7_init[] = {1}; 859 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 860 static int32_t param8_init[] = {1}; 861 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 862 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 863 // Phase 3, inputs and outputs 864 model->identifyInputsAndOutputs( 865 {op1, op2, op3}, 866 {op4}); 867 assert(model->isValid()); 868 } 869 870 inline bool is_ignored_nchw_weight_as_input_quant8(int i) { 871 static std::set<int> ignore = {}; 872 return ignore.find(i) != ignore.end(); 873 } 874 875 void CreateModel_nchw_weight_as_input_float16(Model *model) { 876 OperandType type0(Type::BOOL, {}); 877 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 878 OperandType type12(Type::TENSOR_FLOAT16, {1}); 879 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 880 OperandType type18(Type::TENSOR_FLOAT16, {1, 1, 2, 2}); 881 OperandType type4(Type::INT32, {}); 882 // Phase 1, operands 883 auto op1 = model->addOperand(&type17); 884 auto op2 = model->addOperand(&type11); 885 auto op3 = model->addOperand(&type12); 886 auto param = model->addOperand(&type4); 887 auto param1 = model->addOperand(&type4); 888 auto param2 = model->addOperand(&type4); 889 auto param3 = model->addOperand(&type4); 890 auto param4 = model->addOperand(&type4); 891 auto param5 = model->addOperand(&type4); 892 auto param6 = model->addOperand(&type4); 893 auto layout = model->addOperand(&type0); 894 auto param7 = model->addOperand(&type4); 895 auto param8 = model->addOperand(&type4); 896 auto op4 = model->addOperand(&type18); 897 // Phase 2, operations 898 static int32_t param_init[] = {0}; 899 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 900 static int32_t param1_init[] = {0}; 901 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 902 static int32_t param2_init[] = {0}; 903 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 904 static int32_t param3_init[] = {0}; 905 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 906 static int32_t param4_init[] = {1}; 907 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 908 static int32_t param5_init[] = {1}; 909 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 910 static int32_t param6_init[] = {0}; 911 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 912 static bool8 layout_init[] = {true}; 913 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 914 static int32_t param7_init[] = {1}; 915 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 916 static int32_t param8_init[] = {1}; 917 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 918 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 919 // Phase 3, inputs and outputs 920 model->identifyInputsAndOutputs( 921 {op1, op2, op3}, 922 {op4}); 923 assert(model->isValid()); 924 } 925 926 inline bool is_ignored_nchw_weight_as_input_float16(int i) { 927 static std::set<int> ignore = {}; 928 return ignore.find(i) != ignore.end(); 929 } 930 931 void CreateModel_dynamic_output_shape_nhwc(Model *model) { 932 OperandType type0(Type::BOOL, {}); 933 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 934 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 935 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 936 OperandType type3(Type::TENSOR_FLOAT32, {1}); 937 OperandType type4(Type::INT32, {}); 938 // Phase 1, operands 939 auto op1 = model->addOperand(&type1); 940 auto op2 = model->addOperand(&type2); 941 auto op3 = model->addOperand(&type3); 942 auto param = model->addOperand(&type4); 943 auto param1 = model->addOperand(&type4); 944 auto param2 = model->addOperand(&type4); 945 auto param3 = model->addOperand(&type4); 946 auto param4 = model->addOperand(&type4); 947 auto param5 = model->addOperand(&type4); 948 auto param6 = model->addOperand(&type4); 949 auto layout = model->addOperand(&type0); 950 auto param7 = model->addOperand(&type4); 951 auto param8 = model->addOperand(&type4); 952 auto op4 = model->addOperand(&type19); 953 // Phase 2, operations 954 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 955 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 956 static float op3_init[] = {0.0f}; 957 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 958 static int32_t param_init[] = {0}; 959 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 960 static int32_t param1_init[] = {0}; 961 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 962 static int32_t param2_init[] = {0}; 963 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 964 static int32_t param3_init[] = {0}; 965 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 966 static int32_t param4_init[] = {1}; 967 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 968 static int32_t param5_init[] = {1}; 969 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 970 static int32_t param6_init[] = {0}; 971 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 972 static bool8 layout_init[] = {false}; 973 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 974 static int32_t param7_init[] = {1}; 975 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 976 static int32_t param8_init[] = {1}; 977 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 978 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 979 // Phase 3, inputs and outputs 980 model->identifyInputsAndOutputs( 981 {op1}, 982 {op4}); 983 assert(model->isValid()); 984 } 985 986 inline bool is_ignored_dynamic_output_shape_nhwc(int i) { 987 static std::set<int> ignore = {}; 988 return ignore.find(i) != ignore.end(); 989 } 990 991 void CreateModel_dynamic_output_shape_nhwc_relaxed(Model *model) { 992 OperandType type0(Type::BOOL, {}); 993 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 994 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 995 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 996 OperandType type3(Type::TENSOR_FLOAT32, {1}); 997 OperandType type4(Type::INT32, {}); 998 // Phase 1, operands 999 auto op1 = model->addOperand(&type1); 1000 auto op2 = model->addOperand(&type2); 1001 auto op3 = model->addOperand(&type3); 1002 auto param = model->addOperand(&type4); 1003 auto param1 = model->addOperand(&type4); 1004 auto param2 = model->addOperand(&type4); 1005 auto param3 = model->addOperand(&type4); 1006 auto param4 = model->addOperand(&type4); 1007 auto param5 = model->addOperand(&type4); 1008 auto param6 = model->addOperand(&type4); 1009 auto layout = model->addOperand(&type0); 1010 auto param7 = model->addOperand(&type4); 1011 auto param8 = model->addOperand(&type4); 1012 auto op4 = model->addOperand(&type19); 1013 // Phase 2, operations 1014 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 1015 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 1016 static float op3_init[] = {0.0f}; 1017 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 1018 static int32_t param_init[] = {0}; 1019 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1020 static int32_t param1_init[] = {0}; 1021 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1022 static int32_t param2_init[] = {0}; 1023 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1024 static int32_t param3_init[] = {0}; 1025 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1026 static int32_t param4_init[] = {1}; 1027 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1028 static int32_t param5_init[] = {1}; 1029 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1030 static int32_t param6_init[] = {0}; 1031 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1032 static bool8 layout_init[] = {false}; 1033 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1034 static int32_t param7_init[] = {1}; 1035 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1036 static int32_t param8_init[] = {1}; 1037 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1038 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1039 // Phase 3, inputs and outputs 1040 model->identifyInputsAndOutputs( 1041 {op1}, 1042 {op4}); 1043 // Phase 4: set relaxed execution 1044 model->relaxComputationFloat32toFloat16(true); 1045 assert(model->isValid()); 1046 } 1047 1048 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed(int i) { 1049 static std::set<int> ignore = {}; 1050 return ignore.find(i) != ignore.end(); 1051 } 1052 1053 void CreateModel_dynamic_output_shape_nhwc_quant8(Model *model) { 1054 OperandType type0(Type::BOOL, {}); 1055 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 1056 OperandType type4(Type::INT32, {}); 1057 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 1058 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 1059 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 1060 // Phase 1, operands 1061 auto op1 = model->addOperand(&type7); 1062 auto op2 = model->addOperand(&type8); 1063 auto op3 = model->addOperand(&type9); 1064 auto param = model->addOperand(&type4); 1065 auto param1 = model->addOperand(&type4); 1066 auto param2 = model->addOperand(&type4); 1067 auto param3 = model->addOperand(&type4); 1068 auto param4 = model->addOperand(&type4); 1069 auto param5 = model->addOperand(&type4); 1070 auto param6 = model->addOperand(&type4); 1071 auto layout = model->addOperand(&type0); 1072 auto param7 = model->addOperand(&type4); 1073 auto param8 = model->addOperand(&type4); 1074 auto op4 = model->addOperand(&type20); 1075 // Phase 2, operations 1076 static uint8_t op2_init[] = {2, 2, 2, 2}; 1077 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 4); 1078 static int32_t op3_init[] = {0}; 1079 model->setOperandValue(op3, op3_init, sizeof(int32_t) * 1); 1080 static int32_t param_init[] = {0}; 1081 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1082 static int32_t param1_init[] = {0}; 1083 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1084 static int32_t param2_init[] = {0}; 1085 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1086 static int32_t param3_init[] = {0}; 1087 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1088 static int32_t param4_init[] = {1}; 1089 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1090 static int32_t param5_init[] = {1}; 1091 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1092 static int32_t param6_init[] = {0}; 1093 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1094 static bool8 layout_init[] = {false}; 1095 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1096 static int32_t param7_init[] = {1}; 1097 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1098 static int32_t param8_init[] = {1}; 1099 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1100 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1101 // Phase 3, inputs and outputs 1102 model->identifyInputsAndOutputs( 1103 {op1}, 1104 {op4}); 1105 assert(model->isValid()); 1106 } 1107 1108 inline bool is_ignored_dynamic_output_shape_nhwc_quant8(int i) { 1109 static std::set<int> ignore = {}; 1110 return ignore.find(i) != ignore.end(); 1111 } 1112 1113 void CreateModel_dynamic_output_shape_nhwc_float16(Model *model) { 1114 OperandType type0(Type::BOOL, {}); 1115 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 1116 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 1117 OperandType type12(Type::TENSOR_FLOAT16, {1}); 1118 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 1119 OperandType type4(Type::INT32, {}); 1120 // Phase 1, operands 1121 auto op1 = model->addOperand(&type10); 1122 auto op2 = model->addOperand(&type11); 1123 auto op3 = model->addOperand(&type12); 1124 auto param = model->addOperand(&type4); 1125 auto param1 = model->addOperand(&type4); 1126 auto param2 = model->addOperand(&type4); 1127 auto param3 = model->addOperand(&type4); 1128 auto param4 = model->addOperand(&type4); 1129 auto param5 = model->addOperand(&type4); 1130 auto param6 = model->addOperand(&type4); 1131 auto layout = model->addOperand(&type0); 1132 auto param7 = model->addOperand(&type4); 1133 auto param8 = model->addOperand(&type4); 1134 auto op4 = model->addOperand(&type21); 1135 // Phase 2, operations 1136 static _Float16 op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 1137 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 4); 1138 static _Float16 op3_init[] = {0.0f}; 1139 model->setOperandValue(op3, op3_init, sizeof(_Float16) * 1); 1140 static int32_t param_init[] = {0}; 1141 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1142 static int32_t param1_init[] = {0}; 1143 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1144 static int32_t param2_init[] = {0}; 1145 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1146 static int32_t param3_init[] = {0}; 1147 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1148 static int32_t param4_init[] = {1}; 1149 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1150 static int32_t param5_init[] = {1}; 1151 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1152 static int32_t param6_init[] = {0}; 1153 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1154 static bool8 layout_init[] = {false}; 1155 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1156 static int32_t param7_init[] = {1}; 1157 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1158 static int32_t param8_init[] = {1}; 1159 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1160 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1161 // Phase 3, inputs and outputs 1162 model->identifyInputsAndOutputs( 1163 {op1}, 1164 {op4}); 1165 assert(model->isValid()); 1166 } 1167 1168 inline bool is_ignored_dynamic_output_shape_nhwc_float16(int i) { 1169 static std::set<int> ignore = {}; 1170 return ignore.find(i) != ignore.end(); 1171 } 1172 1173 void CreateModel_dynamic_output_shape_nhwc_weight_as_input(Model *model) { 1174 OperandType type0(Type::BOOL, {}); 1175 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 1176 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1177 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1178 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1179 OperandType type4(Type::INT32, {}); 1180 // Phase 1, operands 1181 auto op1 = model->addOperand(&type1); 1182 auto op2 = model->addOperand(&type2); 1183 auto op3 = model->addOperand(&type3); 1184 auto param = model->addOperand(&type4); 1185 auto param1 = model->addOperand(&type4); 1186 auto param2 = model->addOperand(&type4); 1187 auto param3 = model->addOperand(&type4); 1188 auto param4 = model->addOperand(&type4); 1189 auto param5 = model->addOperand(&type4); 1190 auto param6 = model->addOperand(&type4); 1191 auto layout = model->addOperand(&type0); 1192 auto param7 = model->addOperand(&type4); 1193 auto param8 = model->addOperand(&type4); 1194 auto op4 = model->addOperand(&type19); 1195 // Phase 2, operations 1196 static int32_t param_init[] = {0}; 1197 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1198 static int32_t param1_init[] = {0}; 1199 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1200 static int32_t param2_init[] = {0}; 1201 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1202 static int32_t param3_init[] = {0}; 1203 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1204 static int32_t param4_init[] = {1}; 1205 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1206 static int32_t param5_init[] = {1}; 1207 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1208 static int32_t param6_init[] = {0}; 1209 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1210 static bool8 layout_init[] = {false}; 1211 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1212 static int32_t param7_init[] = {1}; 1213 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1214 static int32_t param8_init[] = {1}; 1215 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1216 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1217 // Phase 3, inputs and outputs 1218 model->identifyInputsAndOutputs( 1219 {op1, op2, op3}, 1220 {op4}); 1221 assert(model->isValid()); 1222 } 1223 1224 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input(int i) { 1225 static std::set<int> ignore = {}; 1226 return ignore.find(i) != ignore.end(); 1227 } 1228 1229 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_relaxed(Model *model) { 1230 OperandType type0(Type::BOOL, {}); 1231 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 1232 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1233 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1234 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1235 OperandType type4(Type::INT32, {}); 1236 // Phase 1, operands 1237 auto op1 = model->addOperand(&type1); 1238 auto op2 = model->addOperand(&type2); 1239 auto op3 = model->addOperand(&type3); 1240 auto param = model->addOperand(&type4); 1241 auto param1 = model->addOperand(&type4); 1242 auto param2 = model->addOperand(&type4); 1243 auto param3 = model->addOperand(&type4); 1244 auto param4 = model->addOperand(&type4); 1245 auto param5 = model->addOperand(&type4); 1246 auto param6 = model->addOperand(&type4); 1247 auto layout = model->addOperand(&type0); 1248 auto param7 = model->addOperand(&type4); 1249 auto param8 = model->addOperand(&type4); 1250 auto op4 = model->addOperand(&type19); 1251 // Phase 2, operations 1252 static int32_t param_init[] = {0}; 1253 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1254 static int32_t param1_init[] = {0}; 1255 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1256 static int32_t param2_init[] = {0}; 1257 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1258 static int32_t param3_init[] = {0}; 1259 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1260 static int32_t param4_init[] = {1}; 1261 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1262 static int32_t param5_init[] = {1}; 1263 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1264 static int32_t param6_init[] = {0}; 1265 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1266 static bool8 layout_init[] = {false}; 1267 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1268 static int32_t param7_init[] = {1}; 1269 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1270 static int32_t param8_init[] = {1}; 1271 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1272 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1273 // Phase 3, inputs and outputs 1274 model->identifyInputsAndOutputs( 1275 {op1, op2, op3}, 1276 {op4}); 1277 // Phase 4: set relaxed execution 1278 model->relaxComputationFloat32toFloat16(true); 1279 assert(model->isValid()); 1280 } 1281 1282 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_relaxed(int i) { 1283 static std::set<int> ignore = {}; 1284 return ignore.find(i) != ignore.end(); 1285 } 1286 1287 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_quant8(Model *model) { 1288 OperandType type0(Type::BOOL, {}); 1289 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 1290 OperandType type4(Type::INT32, {}); 1291 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 1292 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 1293 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 1294 // Phase 1, operands 1295 auto op1 = model->addOperand(&type7); 1296 auto op2 = model->addOperand(&type8); 1297 auto op3 = model->addOperand(&type9); 1298 auto param = model->addOperand(&type4); 1299 auto param1 = model->addOperand(&type4); 1300 auto param2 = model->addOperand(&type4); 1301 auto param3 = model->addOperand(&type4); 1302 auto param4 = model->addOperand(&type4); 1303 auto param5 = model->addOperand(&type4); 1304 auto param6 = model->addOperand(&type4); 1305 auto layout = model->addOperand(&type0); 1306 auto param7 = model->addOperand(&type4); 1307 auto param8 = model->addOperand(&type4); 1308 auto op4 = model->addOperand(&type20); 1309 // Phase 2, operations 1310 static int32_t param_init[] = {0}; 1311 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1312 static int32_t param1_init[] = {0}; 1313 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1314 static int32_t param2_init[] = {0}; 1315 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1316 static int32_t param3_init[] = {0}; 1317 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1318 static int32_t param4_init[] = {1}; 1319 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1320 static int32_t param5_init[] = {1}; 1321 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1322 static int32_t param6_init[] = {0}; 1323 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1324 static bool8 layout_init[] = {false}; 1325 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1326 static int32_t param7_init[] = {1}; 1327 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1328 static int32_t param8_init[] = {1}; 1329 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1330 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1331 // Phase 3, inputs and outputs 1332 model->identifyInputsAndOutputs( 1333 {op1, op2, op3}, 1334 {op4}); 1335 assert(model->isValid()); 1336 } 1337 1338 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_quant8(int i) { 1339 static std::set<int> ignore = {}; 1340 return ignore.find(i) != ignore.end(); 1341 } 1342 1343 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_float16(Model *model) { 1344 OperandType type0(Type::BOOL, {}); 1345 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 1346 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 1347 OperandType type12(Type::TENSOR_FLOAT16, {1}); 1348 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 1349 OperandType type4(Type::INT32, {}); 1350 // Phase 1, operands 1351 auto op1 = model->addOperand(&type10); 1352 auto op2 = model->addOperand(&type11); 1353 auto op3 = model->addOperand(&type12); 1354 auto param = model->addOperand(&type4); 1355 auto param1 = model->addOperand(&type4); 1356 auto param2 = model->addOperand(&type4); 1357 auto param3 = model->addOperand(&type4); 1358 auto param4 = model->addOperand(&type4); 1359 auto param5 = model->addOperand(&type4); 1360 auto param6 = model->addOperand(&type4); 1361 auto layout = model->addOperand(&type0); 1362 auto param7 = model->addOperand(&type4); 1363 auto param8 = model->addOperand(&type4); 1364 auto op4 = model->addOperand(&type21); 1365 // Phase 2, operations 1366 static int32_t param_init[] = {0}; 1367 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1368 static int32_t param1_init[] = {0}; 1369 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1370 static int32_t param2_init[] = {0}; 1371 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1372 static int32_t param3_init[] = {0}; 1373 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1374 static int32_t param4_init[] = {1}; 1375 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1376 static int32_t param5_init[] = {1}; 1377 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1378 static int32_t param6_init[] = {0}; 1379 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1380 static bool8 layout_init[] = {false}; 1381 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1382 static int32_t param7_init[] = {1}; 1383 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1384 static int32_t param8_init[] = {1}; 1385 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1386 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1387 // Phase 3, inputs and outputs 1388 model->identifyInputsAndOutputs( 1389 {op1, op2, op3}, 1390 {op4}); 1391 assert(model->isValid()); 1392 } 1393 1394 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_float16(int i) { 1395 static std::set<int> ignore = {}; 1396 return ignore.find(i) != ignore.end(); 1397 } 1398 1399 void CreateModel_dynamic_output_shape_nchw(Model *model) { 1400 OperandType type0(Type::BOOL, {}); 1401 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 1402 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1403 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1404 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1405 OperandType type4(Type::INT32, {}); 1406 // Phase 1, operands 1407 auto op1 = model->addOperand(&type13); 1408 auto op2 = model->addOperand(&type2); 1409 auto op3 = model->addOperand(&type3); 1410 auto param = model->addOperand(&type4); 1411 auto param1 = model->addOperand(&type4); 1412 auto param2 = model->addOperand(&type4); 1413 auto param3 = model->addOperand(&type4); 1414 auto param4 = model->addOperand(&type4); 1415 auto param5 = model->addOperand(&type4); 1416 auto param6 = model->addOperand(&type4); 1417 auto layout = model->addOperand(&type0); 1418 auto param7 = model->addOperand(&type4); 1419 auto param8 = model->addOperand(&type4); 1420 auto op4 = model->addOperand(&type19); 1421 // Phase 2, operations 1422 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 1423 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 1424 static float op3_init[] = {0.0f}; 1425 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 1426 static int32_t param_init[] = {0}; 1427 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1428 static int32_t param1_init[] = {0}; 1429 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1430 static int32_t param2_init[] = {0}; 1431 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1432 static int32_t param3_init[] = {0}; 1433 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1434 static int32_t param4_init[] = {1}; 1435 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1436 static int32_t param5_init[] = {1}; 1437 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1438 static int32_t param6_init[] = {0}; 1439 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1440 static bool8 layout_init[] = {true}; 1441 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1442 static int32_t param7_init[] = {1}; 1443 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1444 static int32_t param8_init[] = {1}; 1445 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1446 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1447 // Phase 3, inputs and outputs 1448 model->identifyInputsAndOutputs( 1449 {op1}, 1450 {op4}); 1451 assert(model->isValid()); 1452 } 1453 1454 inline bool is_ignored_dynamic_output_shape_nchw(int i) { 1455 static std::set<int> ignore = {}; 1456 return ignore.find(i) != ignore.end(); 1457 } 1458 1459 void CreateModel_dynamic_output_shape_nchw_relaxed(Model *model) { 1460 OperandType type0(Type::BOOL, {}); 1461 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 1462 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1463 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1464 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1465 OperandType type4(Type::INT32, {}); 1466 // Phase 1, operands 1467 auto op1 = model->addOperand(&type13); 1468 auto op2 = model->addOperand(&type2); 1469 auto op3 = model->addOperand(&type3); 1470 auto param = model->addOperand(&type4); 1471 auto param1 = model->addOperand(&type4); 1472 auto param2 = model->addOperand(&type4); 1473 auto param3 = model->addOperand(&type4); 1474 auto param4 = model->addOperand(&type4); 1475 auto param5 = model->addOperand(&type4); 1476 auto param6 = model->addOperand(&type4); 1477 auto layout = model->addOperand(&type0); 1478 auto param7 = model->addOperand(&type4); 1479 auto param8 = model->addOperand(&type4); 1480 auto op4 = model->addOperand(&type19); 1481 // Phase 2, operations 1482 static float op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 1483 model->setOperandValue(op2, op2_init, sizeof(float) * 4); 1484 static float op3_init[] = {0.0f}; 1485 model->setOperandValue(op3, op3_init, sizeof(float) * 1); 1486 static int32_t param_init[] = {0}; 1487 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1488 static int32_t param1_init[] = {0}; 1489 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1490 static int32_t param2_init[] = {0}; 1491 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1492 static int32_t param3_init[] = {0}; 1493 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1494 static int32_t param4_init[] = {1}; 1495 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1496 static int32_t param5_init[] = {1}; 1497 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1498 static int32_t param6_init[] = {0}; 1499 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1500 static bool8 layout_init[] = {true}; 1501 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1502 static int32_t param7_init[] = {1}; 1503 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1504 static int32_t param8_init[] = {1}; 1505 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1506 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1507 // Phase 3, inputs and outputs 1508 model->identifyInputsAndOutputs( 1509 {op1}, 1510 {op4}); 1511 // Phase 4: set relaxed execution 1512 model->relaxComputationFloat32toFloat16(true); 1513 assert(model->isValid()); 1514 } 1515 1516 inline bool is_ignored_dynamic_output_shape_nchw_relaxed(int i) { 1517 static std::set<int> ignore = {}; 1518 return ignore.find(i) != ignore.end(); 1519 } 1520 1521 void CreateModel_dynamic_output_shape_nchw_quant8(Model *model) { 1522 OperandType type0(Type::BOOL, {}); 1523 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 1524 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 1525 OperandType type4(Type::INT32, {}); 1526 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 1527 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 1528 // Phase 1, operands 1529 auto op1 = model->addOperand(&type15); 1530 auto op2 = model->addOperand(&type8); 1531 auto op3 = model->addOperand(&type9); 1532 auto param = model->addOperand(&type4); 1533 auto param1 = model->addOperand(&type4); 1534 auto param2 = model->addOperand(&type4); 1535 auto param3 = model->addOperand(&type4); 1536 auto param4 = model->addOperand(&type4); 1537 auto param5 = model->addOperand(&type4); 1538 auto param6 = model->addOperand(&type4); 1539 auto layout = model->addOperand(&type0); 1540 auto param7 = model->addOperand(&type4); 1541 auto param8 = model->addOperand(&type4); 1542 auto op4 = model->addOperand(&type20); 1543 // Phase 2, operations 1544 static uint8_t op2_init[] = {2, 2, 2, 2}; 1545 model->setOperandValue(op2, op2_init, sizeof(uint8_t) * 4); 1546 static int32_t op3_init[] = {0}; 1547 model->setOperandValue(op3, op3_init, sizeof(int32_t) * 1); 1548 static int32_t param_init[] = {0}; 1549 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1550 static int32_t param1_init[] = {0}; 1551 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1552 static int32_t param2_init[] = {0}; 1553 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1554 static int32_t param3_init[] = {0}; 1555 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1556 static int32_t param4_init[] = {1}; 1557 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1558 static int32_t param5_init[] = {1}; 1559 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1560 static int32_t param6_init[] = {0}; 1561 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1562 static bool8 layout_init[] = {true}; 1563 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1564 static int32_t param7_init[] = {1}; 1565 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1566 static int32_t param8_init[] = {1}; 1567 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1568 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1569 // Phase 3, inputs and outputs 1570 model->identifyInputsAndOutputs( 1571 {op1}, 1572 {op4}); 1573 assert(model->isValid()); 1574 } 1575 1576 inline bool is_ignored_dynamic_output_shape_nchw_quant8(int i) { 1577 static std::set<int> ignore = {}; 1578 return ignore.find(i) != ignore.end(); 1579 } 1580 1581 void CreateModel_dynamic_output_shape_nchw_float16(Model *model) { 1582 OperandType type0(Type::BOOL, {}); 1583 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 1584 OperandType type12(Type::TENSOR_FLOAT16, {1}); 1585 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 1586 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 1587 OperandType type4(Type::INT32, {}); 1588 // Phase 1, operands 1589 auto op1 = model->addOperand(&type17); 1590 auto op2 = model->addOperand(&type11); 1591 auto op3 = model->addOperand(&type12); 1592 auto param = model->addOperand(&type4); 1593 auto param1 = model->addOperand(&type4); 1594 auto param2 = model->addOperand(&type4); 1595 auto param3 = model->addOperand(&type4); 1596 auto param4 = model->addOperand(&type4); 1597 auto param5 = model->addOperand(&type4); 1598 auto param6 = model->addOperand(&type4); 1599 auto layout = model->addOperand(&type0); 1600 auto param7 = model->addOperand(&type4); 1601 auto param8 = model->addOperand(&type4); 1602 auto op4 = model->addOperand(&type21); 1603 // Phase 2, operations 1604 static _Float16 op2_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 1605 model->setOperandValue(op2, op2_init, sizeof(_Float16) * 4); 1606 static _Float16 op3_init[] = {0.0f}; 1607 model->setOperandValue(op3, op3_init, sizeof(_Float16) * 1); 1608 static int32_t param_init[] = {0}; 1609 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1610 static int32_t param1_init[] = {0}; 1611 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1612 static int32_t param2_init[] = {0}; 1613 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1614 static int32_t param3_init[] = {0}; 1615 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1616 static int32_t param4_init[] = {1}; 1617 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1618 static int32_t param5_init[] = {1}; 1619 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1620 static int32_t param6_init[] = {0}; 1621 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1622 static bool8 layout_init[] = {true}; 1623 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1624 static int32_t param7_init[] = {1}; 1625 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1626 static int32_t param8_init[] = {1}; 1627 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1628 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1629 // Phase 3, inputs and outputs 1630 model->identifyInputsAndOutputs( 1631 {op1}, 1632 {op4}); 1633 assert(model->isValid()); 1634 } 1635 1636 inline bool is_ignored_dynamic_output_shape_nchw_float16(int i) { 1637 static std::set<int> ignore = {}; 1638 return ignore.find(i) != ignore.end(); 1639 } 1640 1641 void CreateModel_dynamic_output_shape_nchw_weight_as_input(Model *model) { 1642 OperandType type0(Type::BOOL, {}); 1643 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 1644 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1645 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1646 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1647 OperandType type4(Type::INT32, {}); 1648 // Phase 1, operands 1649 auto op1 = model->addOperand(&type13); 1650 auto op2 = model->addOperand(&type2); 1651 auto op3 = model->addOperand(&type3); 1652 auto param = model->addOperand(&type4); 1653 auto param1 = model->addOperand(&type4); 1654 auto param2 = model->addOperand(&type4); 1655 auto param3 = model->addOperand(&type4); 1656 auto param4 = model->addOperand(&type4); 1657 auto param5 = model->addOperand(&type4); 1658 auto param6 = model->addOperand(&type4); 1659 auto layout = model->addOperand(&type0); 1660 auto param7 = model->addOperand(&type4); 1661 auto param8 = model->addOperand(&type4); 1662 auto op4 = model->addOperand(&type19); 1663 // Phase 2, operations 1664 static int32_t param_init[] = {0}; 1665 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1666 static int32_t param1_init[] = {0}; 1667 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1668 static int32_t param2_init[] = {0}; 1669 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1670 static int32_t param3_init[] = {0}; 1671 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1672 static int32_t param4_init[] = {1}; 1673 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1674 static int32_t param5_init[] = {1}; 1675 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1676 static int32_t param6_init[] = {0}; 1677 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1678 static bool8 layout_init[] = {true}; 1679 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1680 static int32_t param7_init[] = {1}; 1681 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1682 static int32_t param8_init[] = {1}; 1683 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1684 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1685 // Phase 3, inputs and outputs 1686 model->identifyInputsAndOutputs( 1687 {op1, op2, op3}, 1688 {op4}); 1689 assert(model->isValid()); 1690 } 1691 1692 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input(int i) { 1693 static std::set<int> ignore = {}; 1694 return ignore.find(i) != ignore.end(); 1695 } 1696 1697 void CreateModel_dynamic_output_shape_nchw_weight_as_input_relaxed(Model *model) { 1698 OperandType type0(Type::BOOL, {}); 1699 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 1700 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 1701 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 1702 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1703 OperandType type4(Type::INT32, {}); 1704 // Phase 1, operands 1705 auto op1 = model->addOperand(&type13); 1706 auto op2 = model->addOperand(&type2); 1707 auto op3 = model->addOperand(&type3); 1708 auto param = model->addOperand(&type4); 1709 auto param1 = model->addOperand(&type4); 1710 auto param2 = model->addOperand(&type4); 1711 auto param3 = model->addOperand(&type4); 1712 auto param4 = model->addOperand(&type4); 1713 auto param5 = model->addOperand(&type4); 1714 auto param6 = model->addOperand(&type4); 1715 auto layout = model->addOperand(&type0); 1716 auto param7 = model->addOperand(&type4); 1717 auto param8 = model->addOperand(&type4); 1718 auto op4 = model->addOperand(&type19); 1719 // Phase 2, operations 1720 static int32_t param_init[] = {0}; 1721 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1722 static int32_t param1_init[] = {0}; 1723 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1724 static int32_t param2_init[] = {0}; 1725 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1726 static int32_t param3_init[] = {0}; 1727 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1728 static int32_t param4_init[] = {1}; 1729 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1730 static int32_t param5_init[] = {1}; 1731 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1732 static int32_t param6_init[] = {0}; 1733 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1734 static bool8 layout_init[] = {true}; 1735 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1736 static int32_t param7_init[] = {1}; 1737 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1738 static int32_t param8_init[] = {1}; 1739 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1740 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1741 // Phase 3, inputs and outputs 1742 model->identifyInputsAndOutputs( 1743 {op1, op2, op3}, 1744 {op4}); 1745 // Phase 4: set relaxed execution 1746 model->relaxComputationFloat32toFloat16(true); 1747 assert(model->isValid()); 1748 } 1749 1750 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_relaxed(int i) { 1751 static std::set<int> ignore = {}; 1752 return ignore.find(i) != ignore.end(); 1753 } 1754 1755 void CreateModel_dynamic_output_shape_nchw_weight_as_input_quant8(Model *model) { 1756 OperandType type0(Type::BOOL, {}); 1757 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 1758 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 1759 OperandType type4(Type::INT32, {}); 1760 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 1761 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 1762 // Phase 1, operands 1763 auto op1 = model->addOperand(&type15); 1764 auto op2 = model->addOperand(&type8); 1765 auto op3 = model->addOperand(&type9); 1766 auto param = model->addOperand(&type4); 1767 auto param1 = model->addOperand(&type4); 1768 auto param2 = model->addOperand(&type4); 1769 auto param3 = model->addOperand(&type4); 1770 auto param4 = model->addOperand(&type4); 1771 auto param5 = model->addOperand(&type4); 1772 auto param6 = model->addOperand(&type4); 1773 auto layout = model->addOperand(&type0); 1774 auto param7 = model->addOperand(&type4); 1775 auto param8 = model->addOperand(&type4); 1776 auto op4 = model->addOperand(&type20); 1777 // Phase 2, operations 1778 static int32_t param_init[] = {0}; 1779 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1780 static int32_t param1_init[] = {0}; 1781 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1782 static int32_t param2_init[] = {0}; 1783 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1784 static int32_t param3_init[] = {0}; 1785 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1786 static int32_t param4_init[] = {1}; 1787 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1788 static int32_t param5_init[] = {1}; 1789 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1790 static int32_t param6_init[] = {0}; 1791 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1792 static bool8 layout_init[] = {true}; 1793 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1794 static int32_t param7_init[] = {1}; 1795 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1796 static int32_t param8_init[] = {1}; 1797 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1798 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1799 // Phase 3, inputs and outputs 1800 model->identifyInputsAndOutputs( 1801 {op1, op2, op3}, 1802 {op4}); 1803 assert(model->isValid()); 1804 } 1805 1806 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_quant8(int i) { 1807 static std::set<int> ignore = {}; 1808 return ignore.find(i) != ignore.end(); 1809 } 1810 1811 void CreateModel_dynamic_output_shape_nchw_weight_as_input_float16(Model *model) { 1812 OperandType type0(Type::BOOL, {}); 1813 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 1814 OperandType type12(Type::TENSOR_FLOAT16, {1}); 1815 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 1816 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 1817 OperandType type4(Type::INT32, {}); 1818 // Phase 1, operands 1819 auto op1 = model->addOperand(&type17); 1820 auto op2 = model->addOperand(&type11); 1821 auto op3 = model->addOperand(&type12); 1822 auto param = model->addOperand(&type4); 1823 auto param1 = model->addOperand(&type4); 1824 auto param2 = model->addOperand(&type4); 1825 auto param3 = model->addOperand(&type4); 1826 auto param4 = model->addOperand(&type4); 1827 auto param5 = model->addOperand(&type4); 1828 auto param6 = model->addOperand(&type4); 1829 auto layout = model->addOperand(&type0); 1830 auto param7 = model->addOperand(&type4); 1831 auto param8 = model->addOperand(&type4); 1832 auto op4 = model->addOperand(&type21); 1833 // Phase 2, operations 1834 static int32_t param_init[] = {0}; 1835 model->setOperandValue(param, param_init, sizeof(int32_t) * 1); 1836 static int32_t param1_init[] = {0}; 1837 model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1); 1838 static int32_t param2_init[] = {0}; 1839 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1); 1840 static int32_t param3_init[] = {0}; 1841 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1); 1842 static int32_t param4_init[] = {1}; 1843 model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1); 1844 static int32_t param5_init[] = {1}; 1845 model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1); 1846 static int32_t param6_init[] = {0}; 1847 model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1); 1848 static bool8 layout_init[] = {true}; 1849 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1850 static int32_t param7_init[] = {1}; 1851 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1); 1852 static int32_t param8_init[] = {1}; 1853 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1); 1854 model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6, layout, param7, param8}, {op4}); 1855 // Phase 3, inputs and outputs 1856 model->identifyInputsAndOutputs( 1857 {op1, op2, op3}, 1858 {op4}); 1859 assert(model->isValid()); 1860 } 1861 1862 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_float16(int i) { 1863 static std::set<int> ignore = {}; 1864 return ignore.find(i) != ignore.end(); 1865 } 1866 1867 void CreateModel_nhwc_2(Model *model) { 1868 OperandType type0(Type::BOOL, {}); 1869 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 1870 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1871 OperandType type4(Type::INT32, {}); 1872 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 1873 // Phase 1, operands 1874 auto op11 = model->addOperand(&type5); 1875 auto op21 = model->addOperand(&type1); 1876 auto op31 = model->addOperand(&type3); 1877 auto param9 = model->addOperand(&type4); 1878 auto param10 = model->addOperand(&type4); 1879 auto param11 = model->addOperand(&type4); 1880 auto param12 = model->addOperand(&type4); 1881 auto param13 = model->addOperand(&type4); 1882 auto param14 = model->addOperand(&type4); 1883 auto param15 = model->addOperand(&type4); 1884 auto layout = model->addOperand(&type0); 1885 auto param16 = model->addOperand(&type4); 1886 auto param17 = model->addOperand(&type4); 1887 auto op41 = model->addOperand(&type1); 1888 // Phase 2, operations 1889 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 1890 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 1891 static float op31_init[] = {0.0f}; 1892 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 1893 static int32_t param9_init[] = {0}; 1894 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 1895 static int32_t param10_init[] = {0}; 1896 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 1897 static int32_t param11_init[] = {0}; 1898 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 1899 static int32_t param12_init[] = {0}; 1900 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 1901 static int32_t param13_init[] = {1}; 1902 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 1903 static int32_t param14_init[] = {1}; 1904 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 1905 static int32_t param15_init[] = {0}; 1906 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 1907 static bool8 layout_init[] = {false}; 1908 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1909 static int32_t param16_init[] = {3}; 1910 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 1911 static int32_t param17_init[] = {3}; 1912 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 1913 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 1914 // Phase 3, inputs and outputs 1915 model->identifyInputsAndOutputs( 1916 {op11}, 1917 {op41}); 1918 assert(model->isValid()); 1919 } 1920 1921 inline bool is_ignored_nhwc_2(int i) { 1922 static std::set<int> ignore = {}; 1923 return ignore.find(i) != ignore.end(); 1924 } 1925 1926 void CreateModel_nhwc_relaxed_2(Model *model) { 1927 OperandType type0(Type::BOOL, {}); 1928 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 1929 OperandType type3(Type::TENSOR_FLOAT32, {1}); 1930 OperandType type4(Type::INT32, {}); 1931 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 1932 // Phase 1, operands 1933 auto op11 = model->addOperand(&type5); 1934 auto op21 = model->addOperand(&type1); 1935 auto op31 = model->addOperand(&type3); 1936 auto param9 = model->addOperand(&type4); 1937 auto param10 = model->addOperand(&type4); 1938 auto param11 = model->addOperand(&type4); 1939 auto param12 = model->addOperand(&type4); 1940 auto param13 = model->addOperand(&type4); 1941 auto param14 = model->addOperand(&type4); 1942 auto param15 = model->addOperand(&type4); 1943 auto layout = model->addOperand(&type0); 1944 auto param16 = model->addOperand(&type4); 1945 auto param17 = model->addOperand(&type4); 1946 auto op41 = model->addOperand(&type1); 1947 // Phase 2, operations 1948 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 1949 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 1950 static float op31_init[] = {0.0f}; 1951 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 1952 static int32_t param9_init[] = {0}; 1953 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 1954 static int32_t param10_init[] = {0}; 1955 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 1956 static int32_t param11_init[] = {0}; 1957 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 1958 static int32_t param12_init[] = {0}; 1959 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 1960 static int32_t param13_init[] = {1}; 1961 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 1962 static int32_t param14_init[] = {1}; 1963 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 1964 static int32_t param15_init[] = {0}; 1965 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 1966 static bool8 layout_init[] = {false}; 1967 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 1968 static int32_t param16_init[] = {3}; 1969 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 1970 static int32_t param17_init[] = {3}; 1971 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 1972 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 1973 // Phase 3, inputs and outputs 1974 model->identifyInputsAndOutputs( 1975 {op11}, 1976 {op41}); 1977 // Phase 4: set relaxed execution 1978 model->relaxComputationFloat32toFloat16(true); 1979 assert(model->isValid()); 1980 } 1981 1982 inline bool is_ignored_nhwc_relaxed_2(int i) { 1983 static std::set<int> ignore = {}; 1984 return ignore.find(i) != ignore.end(); 1985 } 1986 1987 void CreateModel_nhwc_quant8_2(Model *model) { 1988 OperandType type0(Type::BOOL, {}); 1989 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 1990 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 1991 OperandType type4(Type::INT32, {}); 1992 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 1993 // Phase 1, operands 1994 auto op11 = model->addOperand(&type22); 1995 auto op21 = model->addOperand(&type23); 1996 auto op31 = model->addOperand(&type9); 1997 auto param9 = model->addOperand(&type4); 1998 auto param10 = model->addOperand(&type4); 1999 auto param11 = model->addOperand(&type4); 2000 auto param12 = model->addOperand(&type4); 2001 auto param13 = model->addOperand(&type4); 2002 auto param14 = model->addOperand(&type4); 2003 auto param15 = model->addOperand(&type4); 2004 auto layout = model->addOperand(&type0); 2005 auto param16 = model->addOperand(&type4); 2006 auto param17 = model->addOperand(&type4); 2007 auto op41 = model->addOperand(&type23); 2008 // Phase 2, operations 2009 static uint8_t op21_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 2010 model->setOperandValue(op21, op21_init, sizeof(uint8_t) * 9); 2011 static int32_t op31_init[] = {0}; 2012 model->setOperandValue(op31, op31_init, sizeof(int32_t) * 1); 2013 static int32_t param9_init[] = {0}; 2014 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2015 static int32_t param10_init[] = {0}; 2016 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2017 static int32_t param11_init[] = {0}; 2018 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2019 static int32_t param12_init[] = {0}; 2020 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2021 static int32_t param13_init[] = {1}; 2022 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2023 static int32_t param14_init[] = {1}; 2024 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2025 static int32_t param15_init[] = {0}; 2026 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2027 static bool8 layout_init[] = {false}; 2028 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2029 static int32_t param16_init[] = {3}; 2030 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2031 static int32_t param17_init[] = {3}; 2032 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2033 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2034 // Phase 3, inputs and outputs 2035 model->identifyInputsAndOutputs( 2036 {op11}, 2037 {op41}); 2038 assert(model->isValid()); 2039 } 2040 2041 inline bool is_ignored_nhwc_quant8_2(int i) { 2042 static std::set<int> ignore = {}; 2043 return ignore.find(i) != ignore.end(); 2044 } 2045 2046 void CreateModel_nhwc_float16_2(Model *model) { 2047 OperandType type0(Type::BOOL, {}); 2048 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 2049 OperandType type12(Type::TENSOR_FLOAT16, {1}); 2050 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 2051 OperandType type4(Type::INT32, {}); 2052 // Phase 1, operands 2053 auto op11 = model->addOperand(&type24); 2054 auto op21 = model->addOperand(&type10); 2055 auto op31 = model->addOperand(&type12); 2056 auto param9 = model->addOperand(&type4); 2057 auto param10 = model->addOperand(&type4); 2058 auto param11 = model->addOperand(&type4); 2059 auto param12 = model->addOperand(&type4); 2060 auto param13 = model->addOperand(&type4); 2061 auto param14 = model->addOperand(&type4); 2062 auto param15 = model->addOperand(&type4); 2063 auto layout = model->addOperand(&type0); 2064 auto param16 = model->addOperand(&type4); 2065 auto param17 = model->addOperand(&type4); 2066 auto op41 = model->addOperand(&type10); 2067 // Phase 2, operations 2068 static _Float16 op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2069 model->setOperandValue(op21, op21_init, sizeof(_Float16) * 9); 2070 static _Float16 op31_init[] = {0.0f}; 2071 model->setOperandValue(op31, op31_init, sizeof(_Float16) * 1); 2072 static int32_t param9_init[] = {0}; 2073 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2074 static int32_t param10_init[] = {0}; 2075 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2076 static int32_t param11_init[] = {0}; 2077 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2078 static int32_t param12_init[] = {0}; 2079 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2080 static int32_t param13_init[] = {1}; 2081 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2082 static int32_t param14_init[] = {1}; 2083 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2084 static int32_t param15_init[] = {0}; 2085 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2086 static bool8 layout_init[] = {false}; 2087 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2088 static int32_t param16_init[] = {3}; 2089 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2090 static int32_t param17_init[] = {3}; 2091 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2092 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2093 // Phase 3, inputs and outputs 2094 model->identifyInputsAndOutputs( 2095 {op11}, 2096 {op41}); 2097 assert(model->isValid()); 2098 } 2099 2100 inline bool is_ignored_nhwc_float16_2(int i) { 2101 static std::set<int> ignore = {}; 2102 return ignore.find(i) != ignore.end(); 2103 } 2104 2105 void CreateModel_nhwc_weight_as_input_2(Model *model) { 2106 OperandType type0(Type::BOOL, {}); 2107 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2108 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2109 OperandType type4(Type::INT32, {}); 2110 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 2111 // Phase 1, operands 2112 auto op11 = model->addOperand(&type5); 2113 auto op21 = model->addOperand(&type1); 2114 auto op31 = model->addOperand(&type3); 2115 auto param9 = model->addOperand(&type4); 2116 auto param10 = model->addOperand(&type4); 2117 auto param11 = model->addOperand(&type4); 2118 auto param12 = model->addOperand(&type4); 2119 auto param13 = model->addOperand(&type4); 2120 auto param14 = model->addOperand(&type4); 2121 auto param15 = model->addOperand(&type4); 2122 auto layout = model->addOperand(&type0); 2123 auto param16 = model->addOperand(&type4); 2124 auto param17 = model->addOperand(&type4); 2125 auto op41 = model->addOperand(&type1); 2126 // Phase 2, operations 2127 static int32_t param9_init[] = {0}; 2128 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2129 static int32_t param10_init[] = {0}; 2130 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2131 static int32_t param11_init[] = {0}; 2132 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2133 static int32_t param12_init[] = {0}; 2134 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2135 static int32_t param13_init[] = {1}; 2136 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2137 static int32_t param14_init[] = {1}; 2138 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2139 static int32_t param15_init[] = {0}; 2140 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2141 static bool8 layout_init[] = {false}; 2142 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2143 static int32_t param16_init[] = {3}; 2144 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2145 static int32_t param17_init[] = {3}; 2146 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2147 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2148 // Phase 3, inputs and outputs 2149 model->identifyInputsAndOutputs( 2150 {op11, op21, op31}, 2151 {op41}); 2152 assert(model->isValid()); 2153 } 2154 2155 inline bool is_ignored_nhwc_weight_as_input_2(int i) { 2156 static std::set<int> ignore = {}; 2157 return ignore.find(i) != ignore.end(); 2158 } 2159 2160 void CreateModel_nhwc_weight_as_input_relaxed_2(Model *model) { 2161 OperandType type0(Type::BOOL, {}); 2162 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2163 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2164 OperandType type4(Type::INT32, {}); 2165 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 2166 // Phase 1, operands 2167 auto op11 = model->addOperand(&type5); 2168 auto op21 = model->addOperand(&type1); 2169 auto op31 = model->addOperand(&type3); 2170 auto param9 = model->addOperand(&type4); 2171 auto param10 = model->addOperand(&type4); 2172 auto param11 = model->addOperand(&type4); 2173 auto param12 = model->addOperand(&type4); 2174 auto param13 = model->addOperand(&type4); 2175 auto param14 = model->addOperand(&type4); 2176 auto param15 = model->addOperand(&type4); 2177 auto layout = model->addOperand(&type0); 2178 auto param16 = model->addOperand(&type4); 2179 auto param17 = model->addOperand(&type4); 2180 auto op41 = model->addOperand(&type1); 2181 // Phase 2, operations 2182 static int32_t param9_init[] = {0}; 2183 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2184 static int32_t param10_init[] = {0}; 2185 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2186 static int32_t param11_init[] = {0}; 2187 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2188 static int32_t param12_init[] = {0}; 2189 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2190 static int32_t param13_init[] = {1}; 2191 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2192 static int32_t param14_init[] = {1}; 2193 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2194 static int32_t param15_init[] = {0}; 2195 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2196 static bool8 layout_init[] = {false}; 2197 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2198 static int32_t param16_init[] = {3}; 2199 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2200 static int32_t param17_init[] = {3}; 2201 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2202 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2203 // Phase 3, inputs and outputs 2204 model->identifyInputsAndOutputs( 2205 {op11, op21, op31}, 2206 {op41}); 2207 // Phase 4: set relaxed execution 2208 model->relaxComputationFloat32toFloat16(true); 2209 assert(model->isValid()); 2210 } 2211 2212 inline bool is_ignored_nhwc_weight_as_input_relaxed_2(int i) { 2213 static std::set<int> ignore = {}; 2214 return ignore.find(i) != ignore.end(); 2215 } 2216 2217 void CreateModel_nhwc_weight_as_input_quant8_2(Model *model) { 2218 OperandType type0(Type::BOOL, {}); 2219 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 2220 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 2221 OperandType type4(Type::INT32, {}); 2222 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 2223 // Phase 1, operands 2224 auto op11 = model->addOperand(&type22); 2225 auto op21 = model->addOperand(&type23); 2226 auto op31 = model->addOperand(&type9); 2227 auto param9 = model->addOperand(&type4); 2228 auto param10 = model->addOperand(&type4); 2229 auto param11 = model->addOperand(&type4); 2230 auto param12 = model->addOperand(&type4); 2231 auto param13 = model->addOperand(&type4); 2232 auto param14 = model->addOperand(&type4); 2233 auto param15 = model->addOperand(&type4); 2234 auto layout = model->addOperand(&type0); 2235 auto param16 = model->addOperand(&type4); 2236 auto param17 = model->addOperand(&type4); 2237 auto op41 = model->addOperand(&type23); 2238 // Phase 2, operations 2239 static int32_t param9_init[] = {0}; 2240 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2241 static int32_t param10_init[] = {0}; 2242 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2243 static int32_t param11_init[] = {0}; 2244 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2245 static int32_t param12_init[] = {0}; 2246 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2247 static int32_t param13_init[] = {1}; 2248 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2249 static int32_t param14_init[] = {1}; 2250 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2251 static int32_t param15_init[] = {0}; 2252 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2253 static bool8 layout_init[] = {false}; 2254 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2255 static int32_t param16_init[] = {3}; 2256 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2257 static int32_t param17_init[] = {3}; 2258 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2259 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2260 // Phase 3, inputs and outputs 2261 model->identifyInputsAndOutputs( 2262 {op11, op21, op31}, 2263 {op41}); 2264 assert(model->isValid()); 2265 } 2266 2267 inline bool is_ignored_nhwc_weight_as_input_quant8_2(int i) { 2268 static std::set<int> ignore = {}; 2269 return ignore.find(i) != ignore.end(); 2270 } 2271 2272 void CreateModel_nhwc_weight_as_input_float16_2(Model *model) { 2273 OperandType type0(Type::BOOL, {}); 2274 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 2275 OperandType type12(Type::TENSOR_FLOAT16, {1}); 2276 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 2277 OperandType type4(Type::INT32, {}); 2278 // Phase 1, operands 2279 auto op11 = model->addOperand(&type24); 2280 auto op21 = model->addOperand(&type10); 2281 auto op31 = model->addOperand(&type12); 2282 auto param9 = model->addOperand(&type4); 2283 auto param10 = model->addOperand(&type4); 2284 auto param11 = model->addOperand(&type4); 2285 auto param12 = model->addOperand(&type4); 2286 auto param13 = model->addOperand(&type4); 2287 auto param14 = model->addOperand(&type4); 2288 auto param15 = model->addOperand(&type4); 2289 auto layout = model->addOperand(&type0); 2290 auto param16 = model->addOperand(&type4); 2291 auto param17 = model->addOperand(&type4); 2292 auto op41 = model->addOperand(&type10); 2293 // Phase 2, operations 2294 static int32_t param9_init[] = {0}; 2295 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2296 static int32_t param10_init[] = {0}; 2297 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2298 static int32_t param11_init[] = {0}; 2299 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2300 static int32_t param12_init[] = {0}; 2301 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2302 static int32_t param13_init[] = {1}; 2303 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2304 static int32_t param14_init[] = {1}; 2305 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2306 static int32_t param15_init[] = {0}; 2307 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2308 static bool8 layout_init[] = {false}; 2309 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2310 static int32_t param16_init[] = {3}; 2311 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2312 static int32_t param17_init[] = {3}; 2313 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2314 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2315 // Phase 3, inputs and outputs 2316 model->identifyInputsAndOutputs( 2317 {op11, op21, op31}, 2318 {op41}); 2319 assert(model->isValid()); 2320 } 2321 2322 inline bool is_ignored_nhwc_weight_as_input_float16_2(int i) { 2323 static std::set<int> ignore = {}; 2324 return ignore.find(i) != ignore.end(); 2325 } 2326 2327 void CreateModel_nchw_2(Model *model) { 2328 OperandType type0(Type::BOOL, {}); 2329 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2330 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 2331 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 2332 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2333 OperandType type4(Type::INT32, {}); 2334 // Phase 1, operands 2335 auto op11 = model->addOperand(&type25); 2336 auto op21 = model->addOperand(&type1); 2337 auto op31 = model->addOperand(&type3); 2338 auto param9 = model->addOperand(&type4); 2339 auto param10 = model->addOperand(&type4); 2340 auto param11 = model->addOperand(&type4); 2341 auto param12 = model->addOperand(&type4); 2342 auto param13 = model->addOperand(&type4); 2343 auto param14 = model->addOperand(&type4); 2344 auto param15 = model->addOperand(&type4); 2345 auto layout = model->addOperand(&type0); 2346 auto param16 = model->addOperand(&type4); 2347 auto param17 = model->addOperand(&type4); 2348 auto op41 = model->addOperand(&type13); 2349 // Phase 2, operations 2350 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2351 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 2352 static float op31_init[] = {0.0f}; 2353 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 2354 static int32_t param9_init[] = {0}; 2355 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2356 static int32_t param10_init[] = {0}; 2357 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2358 static int32_t param11_init[] = {0}; 2359 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2360 static int32_t param12_init[] = {0}; 2361 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2362 static int32_t param13_init[] = {1}; 2363 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2364 static int32_t param14_init[] = {1}; 2365 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2366 static int32_t param15_init[] = {0}; 2367 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2368 static bool8 layout_init[] = {true}; 2369 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2370 static int32_t param16_init[] = {3}; 2371 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2372 static int32_t param17_init[] = {3}; 2373 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2374 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2375 // Phase 3, inputs and outputs 2376 model->identifyInputsAndOutputs( 2377 {op11}, 2378 {op41}); 2379 assert(model->isValid()); 2380 } 2381 2382 inline bool is_ignored_nchw_2(int i) { 2383 static std::set<int> ignore = {}; 2384 return ignore.find(i) != ignore.end(); 2385 } 2386 2387 void CreateModel_nchw_relaxed_2(Model *model) { 2388 OperandType type0(Type::BOOL, {}); 2389 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2390 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 2391 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 2392 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2393 OperandType type4(Type::INT32, {}); 2394 // Phase 1, operands 2395 auto op11 = model->addOperand(&type25); 2396 auto op21 = model->addOperand(&type1); 2397 auto op31 = model->addOperand(&type3); 2398 auto param9 = model->addOperand(&type4); 2399 auto param10 = model->addOperand(&type4); 2400 auto param11 = model->addOperand(&type4); 2401 auto param12 = model->addOperand(&type4); 2402 auto param13 = model->addOperand(&type4); 2403 auto param14 = model->addOperand(&type4); 2404 auto param15 = model->addOperand(&type4); 2405 auto layout = model->addOperand(&type0); 2406 auto param16 = model->addOperand(&type4); 2407 auto param17 = model->addOperand(&type4); 2408 auto op41 = model->addOperand(&type13); 2409 // Phase 2, operations 2410 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2411 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 2412 static float op31_init[] = {0.0f}; 2413 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 2414 static int32_t param9_init[] = {0}; 2415 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2416 static int32_t param10_init[] = {0}; 2417 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2418 static int32_t param11_init[] = {0}; 2419 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2420 static int32_t param12_init[] = {0}; 2421 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2422 static int32_t param13_init[] = {1}; 2423 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2424 static int32_t param14_init[] = {1}; 2425 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2426 static int32_t param15_init[] = {0}; 2427 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2428 static bool8 layout_init[] = {true}; 2429 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2430 static int32_t param16_init[] = {3}; 2431 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2432 static int32_t param17_init[] = {3}; 2433 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2434 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2435 // Phase 3, inputs and outputs 2436 model->identifyInputsAndOutputs( 2437 {op11}, 2438 {op41}); 2439 // Phase 4: set relaxed execution 2440 model->relaxComputationFloat32toFloat16(true); 2441 assert(model->isValid()); 2442 } 2443 2444 inline bool is_ignored_nchw_relaxed_2(int i) { 2445 static std::set<int> ignore = {}; 2446 return ignore.find(i) != ignore.end(); 2447 } 2448 2449 void CreateModel_nchw_quant8_2(Model *model) { 2450 OperandType type0(Type::BOOL, {}); 2451 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 2452 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 2453 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 2454 OperandType type4(Type::INT32, {}); 2455 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 2456 // Phase 1, operands 2457 auto op11 = model->addOperand(&type26); 2458 auto op21 = model->addOperand(&type23); 2459 auto op31 = model->addOperand(&type9); 2460 auto param9 = model->addOperand(&type4); 2461 auto param10 = model->addOperand(&type4); 2462 auto param11 = model->addOperand(&type4); 2463 auto param12 = model->addOperand(&type4); 2464 auto param13 = model->addOperand(&type4); 2465 auto param14 = model->addOperand(&type4); 2466 auto param15 = model->addOperand(&type4); 2467 auto layout = model->addOperand(&type0); 2468 auto param16 = model->addOperand(&type4); 2469 auto param17 = model->addOperand(&type4); 2470 auto op41 = model->addOperand(&type27); 2471 // Phase 2, operations 2472 static uint8_t op21_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 2473 model->setOperandValue(op21, op21_init, sizeof(uint8_t) * 9); 2474 static int32_t op31_init[] = {0}; 2475 model->setOperandValue(op31, op31_init, sizeof(int32_t) * 1); 2476 static int32_t param9_init[] = {0}; 2477 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2478 static int32_t param10_init[] = {0}; 2479 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2480 static int32_t param11_init[] = {0}; 2481 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2482 static int32_t param12_init[] = {0}; 2483 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2484 static int32_t param13_init[] = {1}; 2485 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2486 static int32_t param14_init[] = {1}; 2487 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2488 static int32_t param15_init[] = {0}; 2489 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2490 static bool8 layout_init[] = {true}; 2491 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2492 static int32_t param16_init[] = {3}; 2493 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2494 static int32_t param17_init[] = {3}; 2495 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2496 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2497 // Phase 3, inputs and outputs 2498 model->identifyInputsAndOutputs( 2499 {op11}, 2500 {op41}); 2501 assert(model->isValid()); 2502 } 2503 2504 inline bool is_ignored_nchw_quant8_2(int i) { 2505 static std::set<int> ignore = {}; 2506 return ignore.find(i) != ignore.end(); 2507 } 2508 2509 void CreateModel_nchw_float16_2(Model *model) { 2510 OperandType type0(Type::BOOL, {}); 2511 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 2512 OperandType type12(Type::TENSOR_FLOAT16, {1}); 2513 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 2514 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 2515 OperandType type4(Type::INT32, {}); 2516 // Phase 1, operands 2517 auto op11 = model->addOperand(&type28); 2518 auto op21 = model->addOperand(&type10); 2519 auto op31 = model->addOperand(&type12); 2520 auto param9 = model->addOperand(&type4); 2521 auto param10 = model->addOperand(&type4); 2522 auto param11 = model->addOperand(&type4); 2523 auto param12 = model->addOperand(&type4); 2524 auto param13 = model->addOperand(&type4); 2525 auto param14 = model->addOperand(&type4); 2526 auto param15 = model->addOperand(&type4); 2527 auto layout = model->addOperand(&type0); 2528 auto param16 = model->addOperand(&type4); 2529 auto param17 = model->addOperand(&type4); 2530 auto op41 = model->addOperand(&type17); 2531 // Phase 2, operations 2532 static _Float16 op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2533 model->setOperandValue(op21, op21_init, sizeof(_Float16) * 9); 2534 static _Float16 op31_init[] = {0.0f}; 2535 model->setOperandValue(op31, op31_init, sizeof(_Float16) * 1); 2536 static int32_t param9_init[] = {0}; 2537 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2538 static int32_t param10_init[] = {0}; 2539 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2540 static int32_t param11_init[] = {0}; 2541 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2542 static int32_t param12_init[] = {0}; 2543 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2544 static int32_t param13_init[] = {1}; 2545 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2546 static int32_t param14_init[] = {1}; 2547 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2548 static int32_t param15_init[] = {0}; 2549 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2550 static bool8 layout_init[] = {true}; 2551 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2552 static int32_t param16_init[] = {3}; 2553 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2554 static int32_t param17_init[] = {3}; 2555 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2556 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2557 // Phase 3, inputs and outputs 2558 model->identifyInputsAndOutputs( 2559 {op11}, 2560 {op41}); 2561 assert(model->isValid()); 2562 } 2563 2564 inline bool is_ignored_nchw_float16_2(int i) { 2565 static std::set<int> ignore = {}; 2566 return ignore.find(i) != ignore.end(); 2567 } 2568 2569 void CreateModel_nchw_weight_as_input_2(Model *model) { 2570 OperandType type0(Type::BOOL, {}); 2571 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2572 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 2573 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 2574 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2575 OperandType type4(Type::INT32, {}); 2576 // Phase 1, operands 2577 auto op11 = model->addOperand(&type25); 2578 auto op21 = model->addOperand(&type1); 2579 auto op31 = model->addOperand(&type3); 2580 auto param9 = model->addOperand(&type4); 2581 auto param10 = model->addOperand(&type4); 2582 auto param11 = model->addOperand(&type4); 2583 auto param12 = model->addOperand(&type4); 2584 auto param13 = model->addOperand(&type4); 2585 auto param14 = model->addOperand(&type4); 2586 auto param15 = model->addOperand(&type4); 2587 auto layout = model->addOperand(&type0); 2588 auto param16 = model->addOperand(&type4); 2589 auto param17 = model->addOperand(&type4); 2590 auto op41 = model->addOperand(&type13); 2591 // Phase 2, operations 2592 static int32_t param9_init[] = {0}; 2593 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2594 static int32_t param10_init[] = {0}; 2595 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2596 static int32_t param11_init[] = {0}; 2597 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2598 static int32_t param12_init[] = {0}; 2599 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2600 static int32_t param13_init[] = {1}; 2601 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2602 static int32_t param14_init[] = {1}; 2603 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2604 static int32_t param15_init[] = {0}; 2605 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2606 static bool8 layout_init[] = {true}; 2607 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2608 static int32_t param16_init[] = {3}; 2609 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2610 static int32_t param17_init[] = {3}; 2611 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2612 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2613 // Phase 3, inputs and outputs 2614 model->identifyInputsAndOutputs( 2615 {op11, op21, op31}, 2616 {op41}); 2617 assert(model->isValid()); 2618 } 2619 2620 inline bool is_ignored_nchw_weight_as_input_2(int i) { 2621 static std::set<int> ignore = {}; 2622 return ignore.find(i) != ignore.end(); 2623 } 2624 2625 void CreateModel_nchw_weight_as_input_relaxed_2(Model *model) { 2626 OperandType type0(Type::BOOL, {}); 2627 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2628 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 2629 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 2630 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2631 OperandType type4(Type::INT32, {}); 2632 // Phase 1, operands 2633 auto op11 = model->addOperand(&type25); 2634 auto op21 = model->addOperand(&type1); 2635 auto op31 = model->addOperand(&type3); 2636 auto param9 = model->addOperand(&type4); 2637 auto param10 = model->addOperand(&type4); 2638 auto param11 = model->addOperand(&type4); 2639 auto param12 = model->addOperand(&type4); 2640 auto param13 = model->addOperand(&type4); 2641 auto param14 = model->addOperand(&type4); 2642 auto param15 = model->addOperand(&type4); 2643 auto layout = model->addOperand(&type0); 2644 auto param16 = model->addOperand(&type4); 2645 auto param17 = model->addOperand(&type4); 2646 auto op41 = model->addOperand(&type13); 2647 // Phase 2, operations 2648 static int32_t param9_init[] = {0}; 2649 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2650 static int32_t param10_init[] = {0}; 2651 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2652 static int32_t param11_init[] = {0}; 2653 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2654 static int32_t param12_init[] = {0}; 2655 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2656 static int32_t param13_init[] = {1}; 2657 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2658 static int32_t param14_init[] = {1}; 2659 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2660 static int32_t param15_init[] = {0}; 2661 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2662 static bool8 layout_init[] = {true}; 2663 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2664 static int32_t param16_init[] = {3}; 2665 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2666 static int32_t param17_init[] = {3}; 2667 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2668 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2669 // Phase 3, inputs and outputs 2670 model->identifyInputsAndOutputs( 2671 {op11, op21, op31}, 2672 {op41}); 2673 // Phase 4: set relaxed execution 2674 model->relaxComputationFloat32toFloat16(true); 2675 assert(model->isValid()); 2676 } 2677 2678 inline bool is_ignored_nchw_weight_as_input_relaxed_2(int i) { 2679 static std::set<int> ignore = {}; 2680 return ignore.find(i) != ignore.end(); 2681 } 2682 2683 void CreateModel_nchw_weight_as_input_quant8_2(Model *model) { 2684 OperandType type0(Type::BOOL, {}); 2685 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 2686 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 2687 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 2688 OperandType type4(Type::INT32, {}); 2689 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 2690 // Phase 1, operands 2691 auto op11 = model->addOperand(&type26); 2692 auto op21 = model->addOperand(&type23); 2693 auto op31 = model->addOperand(&type9); 2694 auto param9 = model->addOperand(&type4); 2695 auto param10 = model->addOperand(&type4); 2696 auto param11 = model->addOperand(&type4); 2697 auto param12 = model->addOperand(&type4); 2698 auto param13 = model->addOperand(&type4); 2699 auto param14 = model->addOperand(&type4); 2700 auto param15 = model->addOperand(&type4); 2701 auto layout = model->addOperand(&type0); 2702 auto param16 = model->addOperand(&type4); 2703 auto param17 = model->addOperand(&type4); 2704 auto op41 = model->addOperand(&type27); 2705 // Phase 2, operations 2706 static int32_t param9_init[] = {0}; 2707 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2708 static int32_t param10_init[] = {0}; 2709 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2710 static int32_t param11_init[] = {0}; 2711 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2712 static int32_t param12_init[] = {0}; 2713 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2714 static int32_t param13_init[] = {1}; 2715 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2716 static int32_t param14_init[] = {1}; 2717 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2718 static int32_t param15_init[] = {0}; 2719 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2720 static bool8 layout_init[] = {true}; 2721 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2722 static int32_t param16_init[] = {3}; 2723 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2724 static int32_t param17_init[] = {3}; 2725 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2726 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2727 // Phase 3, inputs and outputs 2728 model->identifyInputsAndOutputs( 2729 {op11, op21, op31}, 2730 {op41}); 2731 assert(model->isValid()); 2732 } 2733 2734 inline bool is_ignored_nchw_weight_as_input_quant8_2(int i) { 2735 static std::set<int> ignore = {}; 2736 return ignore.find(i) != ignore.end(); 2737 } 2738 2739 void CreateModel_nchw_weight_as_input_float16_2(Model *model) { 2740 OperandType type0(Type::BOOL, {}); 2741 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 2742 OperandType type12(Type::TENSOR_FLOAT16, {1}); 2743 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 2744 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 2745 OperandType type4(Type::INT32, {}); 2746 // Phase 1, operands 2747 auto op11 = model->addOperand(&type28); 2748 auto op21 = model->addOperand(&type10); 2749 auto op31 = model->addOperand(&type12); 2750 auto param9 = model->addOperand(&type4); 2751 auto param10 = model->addOperand(&type4); 2752 auto param11 = model->addOperand(&type4); 2753 auto param12 = model->addOperand(&type4); 2754 auto param13 = model->addOperand(&type4); 2755 auto param14 = model->addOperand(&type4); 2756 auto param15 = model->addOperand(&type4); 2757 auto layout = model->addOperand(&type0); 2758 auto param16 = model->addOperand(&type4); 2759 auto param17 = model->addOperand(&type4); 2760 auto op41 = model->addOperand(&type17); 2761 // Phase 2, operations 2762 static int32_t param9_init[] = {0}; 2763 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2764 static int32_t param10_init[] = {0}; 2765 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2766 static int32_t param11_init[] = {0}; 2767 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2768 static int32_t param12_init[] = {0}; 2769 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2770 static int32_t param13_init[] = {1}; 2771 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2772 static int32_t param14_init[] = {1}; 2773 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2774 static int32_t param15_init[] = {0}; 2775 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2776 static bool8 layout_init[] = {true}; 2777 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2778 static int32_t param16_init[] = {3}; 2779 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2780 static int32_t param17_init[] = {3}; 2781 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2782 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2783 // Phase 3, inputs and outputs 2784 model->identifyInputsAndOutputs( 2785 {op11, op21, op31}, 2786 {op41}); 2787 assert(model->isValid()); 2788 } 2789 2790 inline bool is_ignored_nchw_weight_as_input_float16_2(int i) { 2791 static std::set<int> ignore = {}; 2792 return ignore.find(i) != ignore.end(); 2793 } 2794 2795 void CreateModel_dynamic_output_shape_nhwc_2(Model *model) { 2796 OperandType type0(Type::BOOL, {}); 2797 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2798 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 2799 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2800 OperandType type4(Type::INT32, {}); 2801 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 2802 // Phase 1, operands 2803 auto op11 = model->addOperand(&type5); 2804 auto op21 = model->addOperand(&type1); 2805 auto op31 = model->addOperand(&type3); 2806 auto param9 = model->addOperand(&type4); 2807 auto param10 = model->addOperand(&type4); 2808 auto param11 = model->addOperand(&type4); 2809 auto param12 = model->addOperand(&type4); 2810 auto param13 = model->addOperand(&type4); 2811 auto param14 = model->addOperand(&type4); 2812 auto param15 = model->addOperand(&type4); 2813 auto layout = model->addOperand(&type0); 2814 auto param16 = model->addOperand(&type4); 2815 auto param17 = model->addOperand(&type4); 2816 auto op41 = model->addOperand(&type19); 2817 // Phase 2, operations 2818 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2819 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 2820 static float op31_init[] = {0.0f}; 2821 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 2822 static int32_t param9_init[] = {0}; 2823 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2824 static int32_t param10_init[] = {0}; 2825 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2826 static int32_t param11_init[] = {0}; 2827 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2828 static int32_t param12_init[] = {0}; 2829 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2830 static int32_t param13_init[] = {1}; 2831 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2832 static int32_t param14_init[] = {1}; 2833 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2834 static int32_t param15_init[] = {0}; 2835 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2836 static bool8 layout_init[] = {false}; 2837 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2838 static int32_t param16_init[] = {3}; 2839 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2840 static int32_t param17_init[] = {3}; 2841 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2842 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2843 // Phase 3, inputs and outputs 2844 model->identifyInputsAndOutputs( 2845 {op11}, 2846 {op41}); 2847 assert(model->isValid()); 2848 } 2849 2850 inline bool is_ignored_dynamic_output_shape_nhwc_2(int i) { 2851 static std::set<int> ignore = {}; 2852 return ignore.find(i) != ignore.end(); 2853 } 2854 2855 void CreateModel_dynamic_output_shape_nhwc_relaxed_2(Model *model) { 2856 OperandType type0(Type::BOOL, {}); 2857 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 2858 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 2859 OperandType type3(Type::TENSOR_FLOAT32, {1}); 2860 OperandType type4(Type::INT32, {}); 2861 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 2862 // Phase 1, operands 2863 auto op11 = model->addOperand(&type5); 2864 auto op21 = model->addOperand(&type1); 2865 auto op31 = model->addOperand(&type3); 2866 auto param9 = model->addOperand(&type4); 2867 auto param10 = model->addOperand(&type4); 2868 auto param11 = model->addOperand(&type4); 2869 auto param12 = model->addOperand(&type4); 2870 auto param13 = model->addOperand(&type4); 2871 auto param14 = model->addOperand(&type4); 2872 auto param15 = model->addOperand(&type4); 2873 auto layout = model->addOperand(&type0); 2874 auto param16 = model->addOperand(&type4); 2875 auto param17 = model->addOperand(&type4); 2876 auto op41 = model->addOperand(&type19); 2877 // Phase 2, operations 2878 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 2879 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 2880 static float op31_init[] = {0.0f}; 2881 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 2882 static int32_t param9_init[] = {0}; 2883 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2884 static int32_t param10_init[] = {0}; 2885 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2886 static int32_t param11_init[] = {0}; 2887 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2888 static int32_t param12_init[] = {0}; 2889 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2890 static int32_t param13_init[] = {1}; 2891 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2892 static int32_t param14_init[] = {1}; 2893 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2894 static int32_t param15_init[] = {0}; 2895 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2896 static bool8 layout_init[] = {false}; 2897 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2898 static int32_t param16_init[] = {3}; 2899 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2900 static int32_t param17_init[] = {3}; 2901 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2902 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2903 // Phase 3, inputs and outputs 2904 model->identifyInputsAndOutputs( 2905 {op11}, 2906 {op41}); 2907 // Phase 4: set relaxed execution 2908 model->relaxComputationFloat32toFloat16(true); 2909 assert(model->isValid()); 2910 } 2911 2912 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_2(int i) { 2913 static std::set<int> ignore = {}; 2914 return ignore.find(i) != ignore.end(); 2915 } 2916 2917 void CreateModel_dynamic_output_shape_nhwc_quant8_2(Model *model) { 2918 OperandType type0(Type::BOOL, {}); 2919 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 2920 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 2921 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 2922 OperandType type4(Type::INT32, {}); 2923 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 2924 // Phase 1, operands 2925 auto op11 = model->addOperand(&type22); 2926 auto op21 = model->addOperand(&type23); 2927 auto op31 = model->addOperand(&type9); 2928 auto param9 = model->addOperand(&type4); 2929 auto param10 = model->addOperand(&type4); 2930 auto param11 = model->addOperand(&type4); 2931 auto param12 = model->addOperand(&type4); 2932 auto param13 = model->addOperand(&type4); 2933 auto param14 = model->addOperand(&type4); 2934 auto param15 = model->addOperand(&type4); 2935 auto layout = model->addOperand(&type0); 2936 auto param16 = model->addOperand(&type4); 2937 auto param17 = model->addOperand(&type4); 2938 auto op41 = model->addOperand(&type20); 2939 // Phase 2, operations 2940 static uint8_t op21_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 2941 model->setOperandValue(op21, op21_init, sizeof(uint8_t) * 9); 2942 static int32_t op31_init[] = {0}; 2943 model->setOperandValue(op31, op31_init, sizeof(int32_t) * 1); 2944 static int32_t param9_init[] = {0}; 2945 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 2946 static int32_t param10_init[] = {0}; 2947 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 2948 static int32_t param11_init[] = {0}; 2949 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 2950 static int32_t param12_init[] = {0}; 2951 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 2952 static int32_t param13_init[] = {1}; 2953 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 2954 static int32_t param14_init[] = {1}; 2955 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 2956 static int32_t param15_init[] = {0}; 2957 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 2958 static bool8 layout_init[] = {false}; 2959 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 2960 static int32_t param16_init[] = {3}; 2961 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 2962 static int32_t param17_init[] = {3}; 2963 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 2964 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 2965 // Phase 3, inputs and outputs 2966 model->identifyInputsAndOutputs( 2967 {op11}, 2968 {op41}); 2969 assert(model->isValid()); 2970 } 2971 2972 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_2(int i) { 2973 static std::set<int> ignore = {}; 2974 return ignore.find(i) != ignore.end(); 2975 } 2976 2977 void CreateModel_dynamic_output_shape_nhwc_float16_2(Model *model) { 2978 OperandType type0(Type::BOOL, {}); 2979 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 2980 OperandType type12(Type::TENSOR_FLOAT16, {1}); 2981 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 2982 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 2983 OperandType type4(Type::INT32, {}); 2984 // Phase 1, operands 2985 auto op11 = model->addOperand(&type24); 2986 auto op21 = model->addOperand(&type10); 2987 auto op31 = model->addOperand(&type12); 2988 auto param9 = model->addOperand(&type4); 2989 auto param10 = model->addOperand(&type4); 2990 auto param11 = model->addOperand(&type4); 2991 auto param12 = model->addOperand(&type4); 2992 auto param13 = model->addOperand(&type4); 2993 auto param14 = model->addOperand(&type4); 2994 auto param15 = model->addOperand(&type4); 2995 auto layout = model->addOperand(&type0); 2996 auto param16 = model->addOperand(&type4); 2997 auto param17 = model->addOperand(&type4); 2998 auto op41 = model->addOperand(&type21); 2999 // Phase 2, operations 3000 static _Float16 op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 3001 model->setOperandValue(op21, op21_init, sizeof(_Float16) * 9); 3002 static _Float16 op31_init[] = {0.0f}; 3003 model->setOperandValue(op31, op31_init, sizeof(_Float16) * 1); 3004 static int32_t param9_init[] = {0}; 3005 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3006 static int32_t param10_init[] = {0}; 3007 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3008 static int32_t param11_init[] = {0}; 3009 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3010 static int32_t param12_init[] = {0}; 3011 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3012 static int32_t param13_init[] = {1}; 3013 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3014 static int32_t param14_init[] = {1}; 3015 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3016 static int32_t param15_init[] = {0}; 3017 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3018 static bool8 layout_init[] = {false}; 3019 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3020 static int32_t param16_init[] = {3}; 3021 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3022 static int32_t param17_init[] = {3}; 3023 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3024 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3025 // Phase 3, inputs and outputs 3026 model->identifyInputsAndOutputs( 3027 {op11}, 3028 {op41}); 3029 assert(model->isValid()); 3030 } 3031 3032 inline bool is_ignored_dynamic_output_shape_nhwc_float16_2(int i) { 3033 static std::set<int> ignore = {}; 3034 return ignore.find(i) != ignore.end(); 3035 } 3036 3037 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_2(Model *model) { 3038 OperandType type0(Type::BOOL, {}); 3039 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3040 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3041 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3042 OperandType type4(Type::INT32, {}); 3043 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 3044 // Phase 1, operands 3045 auto op11 = model->addOperand(&type5); 3046 auto op21 = model->addOperand(&type1); 3047 auto op31 = model->addOperand(&type3); 3048 auto param9 = model->addOperand(&type4); 3049 auto param10 = model->addOperand(&type4); 3050 auto param11 = model->addOperand(&type4); 3051 auto param12 = model->addOperand(&type4); 3052 auto param13 = model->addOperand(&type4); 3053 auto param14 = model->addOperand(&type4); 3054 auto param15 = model->addOperand(&type4); 3055 auto layout = model->addOperand(&type0); 3056 auto param16 = model->addOperand(&type4); 3057 auto param17 = model->addOperand(&type4); 3058 auto op41 = model->addOperand(&type19); 3059 // Phase 2, operations 3060 static int32_t param9_init[] = {0}; 3061 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3062 static int32_t param10_init[] = {0}; 3063 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3064 static int32_t param11_init[] = {0}; 3065 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3066 static int32_t param12_init[] = {0}; 3067 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3068 static int32_t param13_init[] = {1}; 3069 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3070 static int32_t param14_init[] = {1}; 3071 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3072 static int32_t param15_init[] = {0}; 3073 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3074 static bool8 layout_init[] = {false}; 3075 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3076 static int32_t param16_init[] = {3}; 3077 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3078 static int32_t param17_init[] = {3}; 3079 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3080 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3081 // Phase 3, inputs and outputs 3082 model->identifyInputsAndOutputs( 3083 {op11, op21, op31}, 3084 {op41}); 3085 assert(model->isValid()); 3086 } 3087 3088 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_2(int i) { 3089 static std::set<int> ignore = {}; 3090 return ignore.find(i) != ignore.end(); 3091 } 3092 3093 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_relaxed_2(Model *model) { 3094 OperandType type0(Type::BOOL, {}); 3095 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3096 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3097 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3098 OperandType type4(Type::INT32, {}); 3099 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 3100 // Phase 1, operands 3101 auto op11 = model->addOperand(&type5); 3102 auto op21 = model->addOperand(&type1); 3103 auto op31 = model->addOperand(&type3); 3104 auto param9 = model->addOperand(&type4); 3105 auto param10 = model->addOperand(&type4); 3106 auto param11 = model->addOperand(&type4); 3107 auto param12 = model->addOperand(&type4); 3108 auto param13 = model->addOperand(&type4); 3109 auto param14 = model->addOperand(&type4); 3110 auto param15 = model->addOperand(&type4); 3111 auto layout = model->addOperand(&type0); 3112 auto param16 = model->addOperand(&type4); 3113 auto param17 = model->addOperand(&type4); 3114 auto op41 = model->addOperand(&type19); 3115 // Phase 2, operations 3116 static int32_t param9_init[] = {0}; 3117 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3118 static int32_t param10_init[] = {0}; 3119 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3120 static int32_t param11_init[] = {0}; 3121 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3122 static int32_t param12_init[] = {0}; 3123 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3124 static int32_t param13_init[] = {1}; 3125 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3126 static int32_t param14_init[] = {1}; 3127 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3128 static int32_t param15_init[] = {0}; 3129 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3130 static bool8 layout_init[] = {false}; 3131 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3132 static int32_t param16_init[] = {3}; 3133 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3134 static int32_t param17_init[] = {3}; 3135 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3136 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3137 // Phase 3, inputs and outputs 3138 model->identifyInputsAndOutputs( 3139 {op11, op21, op31}, 3140 {op41}); 3141 // Phase 4: set relaxed execution 3142 model->relaxComputationFloat32toFloat16(true); 3143 assert(model->isValid()); 3144 } 3145 3146 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_relaxed_2(int i) { 3147 static std::set<int> ignore = {}; 3148 return ignore.find(i) != ignore.end(); 3149 } 3150 3151 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_quant8_2(Model *model) { 3152 OperandType type0(Type::BOOL, {}); 3153 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 3154 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 3155 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 3156 OperandType type4(Type::INT32, {}); 3157 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 3158 // Phase 1, operands 3159 auto op11 = model->addOperand(&type22); 3160 auto op21 = model->addOperand(&type23); 3161 auto op31 = model->addOperand(&type9); 3162 auto param9 = model->addOperand(&type4); 3163 auto param10 = model->addOperand(&type4); 3164 auto param11 = model->addOperand(&type4); 3165 auto param12 = model->addOperand(&type4); 3166 auto param13 = model->addOperand(&type4); 3167 auto param14 = model->addOperand(&type4); 3168 auto param15 = model->addOperand(&type4); 3169 auto layout = model->addOperand(&type0); 3170 auto param16 = model->addOperand(&type4); 3171 auto param17 = model->addOperand(&type4); 3172 auto op41 = model->addOperand(&type20); 3173 // Phase 2, operations 3174 static int32_t param9_init[] = {0}; 3175 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3176 static int32_t param10_init[] = {0}; 3177 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3178 static int32_t param11_init[] = {0}; 3179 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3180 static int32_t param12_init[] = {0}; 3181 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3182 static int32_t param13_init[] = {1}; 3183 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3184 static int32_t param14_init[] = {1}; 3185 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3186 static int32_t param15_init[] = {0}; 3187 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3188 static bool8 layout_init[] = {false}; 3189 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3190 static int32_t param16_init[] = {3}; 3191 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3192 static int32_t param17_init[] = {3}; 3193 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3194 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3195 // Phase 3, inputs and outputs 3196 model->identifyInputsAndOutputs( 3197 {op11, op21, op31}, 3198 {op41}); 3199 assert(model->isValid()); 3200 } 3201 3202 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_quant8_2(int i) { 3203 static std::set<int> ignore = {}; 3204 return ignore.find(i) != ignore.end(); 3205 } 3206 3207 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_float16_2(Model *model) { 3208 OperandType type0(Type::BOOL, {}); 3209 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 3210 OperandType type12(Type::TENSOR_FLOAT16, {1}); 3211 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 3212 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 3213 OperandType type4(Type::INT32, {}); 3214 // Phase 1, operands 3215 auto op11 = model->addOperand(&type24); 3216 auto op21 = model->addOperand(&type10); 3217 auto op31 = model->addOperand(&type12); 3218 auto param9 = model->addOperand(&type4); 3219 auto param10 = model->addOperand(&type4); 3220 auto param11 = model->addOperand(&type4); 3221 auto param12 = model->addOperand(&type4); 3222 auto param13 = model->addOperand(&type4); 3223 auto param14 = model->addOperand(&type4); 3224 auto param15 = model->addOperand(&type4); 3225 auto layout = model->addOperand(&type0); 3226 auto param16 = model->addOperand(&type4); 3227 auto param17 = model->addOperand(&type4); 3228 auto op41 = model->addOperand(&type21); 3229 // Phase 2, operations 3230 static int32_t param9_init[] = {0}; 3231 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3232 static int32_t param10_init[] = {0}; 3233 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3234 static int32_t param11_init[] = {0}; 3235 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3236 static int32_t param12_init[] = {0}; 3237 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3238 static int32_t param13_init[] = {1}; 3239 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3240 static int32_t param14_init[] = {1}; 3241 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3242 static int32_t param15_init[] = {0}; 3243 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3244 static bool8 layout_init[] = {false}; 3245 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3246 static int32_t param16_init[] = {3}; 3247 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3248 static int32_t param17_init[] = {3}; 3249 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3250 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3251 // Phase 3, inputs and outputs 3252 model->identifyInputsAndOutputs( 3253 {op11, op21, op31}, 3254 {op41}); 3255 assert(model->isValid()); 3256 } 3257 3258 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_float16_2(int i) { 3259 static std::set<int> ignore = {}; 3260 return ignore.find(i) != ignore.end(); 3261 } 3262 3263 void CreateModel_dynamic_output_shape_nchw_2(Model *model) { 3264 OperandType type0(Type::BOOL, {}); 3265 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3266 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3267 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 3268 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3269 OperandType type4(Type::INT32, {}); 3270 // Phase 1, operands 3271 auto op11 = model->addOperand(&type25); 3272 auto op21 = model->addOperand(&type1); 3273 auto op31 = model->addOperand(&type3); 3274 auto param9 = model->addOperand(&type4); 3275 auto param10 = model->addOperand(&type4); 3276 auto param11 = model->addOperand(&type4); 3277 auto param12 = model->addOperand(&type4); 3278 auto param13 = model->addOperand(&type4); 3279 auto param14 = model->addOperand(&type4); 3280 auto param15 = model->addOperand(&type4); 3281 auto layout = model->addOperand(&type0); 3282 auto param16 = model->addOperand(&type4); 3283 auto param17 = model->addOperand(&type4); 3284 auto op41 = model->addOperand(&type19); 3285 // Phase 2, operations 3286 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 3287 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 3288 static float op31_init[] = {0.0f}; 3289 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 3290 static int32_t param9_init[] = {0}; 3291 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3292 static int32_t param10_init[] = {0}; 3293 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3294 static int32_t param11_init[] = {0}; 3295 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3296 static int32_t param12_init[] = {0}; 3297 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3298 static int32_t param13_init[] = {1}; 3299 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3300 static int32_t param14_init[] = {1}; 3301 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3302 static int32_t param15_init[] = {0}; 3303 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3304 static bool8 layout_init[] = {true}; 3305 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3306 static int32_t param16_init[] = {3}; 3307 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3308 static int32_t param17_init[] = {3}; 3309 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3310 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3311 // Phase 3, inputs and outputs 3312 model->identifyInputsAndOutputs( 3313 {op11}, 3314 {op41}); 3315 assert(model->isValid()); 3316 } 3317 3318 inline bool is_ignored_dynamic_output_shape_nchw_2(int i) { 3319 static std::set<int> ignore = {}; 3320 return ignore.find(i) != ignore.end(); 3321 } 3322 3323 void CreateModel_dynamic_output_shape_nchw_relaxed_2(Model *model) { 3324 OperandType type0(Type::BOOL, {}); 3325 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3326 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3327 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 3328 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3329 OperandType type4(Type::INT32, {}); 3330 // Phase 1, operands 3331 auto op11 = model->addOperand(&type25); 3332 auto op21 = model->addOperand(&type1); 3333 auto op31 = model->addOperand(&type3); 3334 auto param9 = model->addOperand(&type4); 3335 auto param10 = model->addOperand(&type4); 3336 auto param11 = model->addOperand(&type4); 3337 auto param12 = model->addOperand(&type4); 3338 auto param13 = model->addOperand(&type4); 3339 auto param14 = model->addOperand(&type4); 3340 auto param15 = model->addOperand(&type4); 3341 auto layout = model->addOperand(&type0); 3342 auto param16 = model->addOperand(&type4); 3343 auto param17 = model->addOperand(&type4); 3344 auto op41 = model->addOperand(&type19); 3345 // Phase 2, operations 3346 static float op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 3347 model->setOperandValue(op21, op21_init, sizeof(float) * 9); 3348 static float op31_init[] = {0.0f}; 3349 model->setOperandValue(op31, op31_init, sizeof(float) * 1); 3350 static int32_t param9_init[] = {0}; 3351 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3352 static int32_t param10_init[] = {0}; 3353 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3354 static int32_t param11_init[] = {0}; 3355 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3356 static int32_t param12_init[] = {0}; 3357 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3358 static int32_t param13_init[] = {1}; 3359 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3360 static int32_t param14_init[] = {1}; 3361 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3362 static int32_t param15_init[] = {0}; 3363 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3364 static bool8 layout_init[] = {true}; 3365 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3366 static int32_t param16_init[] = {3}; 3367 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3368 static int32_t param17_init[] = {3}; 3369 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3370 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3371 // Phase 3, inputs and outputs 3372 model->identifyInputsAndOutputs( 3373 {op11}, 3374 {op41}); 3375 // Phase 4: set relaxed execution 3376 model->relaxComputationFloat32toFloat16(true); 3377 assert(model->isValid()); 3378 } 3379 3380 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_2(int i) { 3381 static std::set<int> ignore = {}; 3382 return ignore.find(i) != ignore.end(); 3383 } 3384 3385 void CreateModel_dynamic_output_shape_nchw_quant8_2(Model *model) { 3386 OperandType type0(Type::BOOL, {}); 3387 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 3388 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 3389 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 3390 OperandType type4(Type::INT32, {}); 3391 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 3392 // Phase 1, operands 3393 auto op11 = model->addOperand(&type26); 3394 auto op21 = model->addOperand(&type23); 3395 auto op31 = model->addOperand(&type9); 3396 auto param9 = model->addOperand(&type4); 3397 auto param10 = model->addOperand(&type4); 3398 auto param11 = model->addOperand(&type4); 3399 auto param12 = model->addOperand(&type4); 3400 auto param13 = model->addOperand(&type4); 3401 auto param14 = model->addOperand(&type4); 3402 auto param15 = model->addOperand(&type4); 3403 auto layout = model->addOperand(&type0); 3404 auto param16 = model->addOperand(&type4); 3405 auto param17 = model->addOperand(&type4); 3406 auto op41 = model->addOperand(&type20); 3407 // Phase 2, operations 3408 static uint8_t op21_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 3409 model->setOperandValue(op21, op21_init, sizeof(uint8_t) * 9); 3410 static int32_t op31_init[] = {0}; 3411 model->setOperandValue(op31, op31_init, sizeof(int32_t) * 1); 3412 static int32_t param9_init[] = {0}; 3413 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3414 static int32_t param10_init[] = {0}; 3415 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3416 static int32_t param11_init[] = {0}; 3417 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3418 static int32_t param12_init[] = {0}; 3419 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3420 static int32_t param13_init[] = {1}; 3421 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3422 static int32_t param14_init[] = {1}; 3423 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3424 static int32_t param15_init[] = {0}; 3425 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3426 static bool8 layout_init[] = {true}; 3427 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3428 static int32_t param16_init[] = {3}; 3429 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3430 static int32_t param17_init[] = {3}; 3431 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3432 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3433 // Phase 3, inputs and outputs 3434 model->identifyInputsAndOutputs( 3435 {op11}, 3436 {op41}); 3437 assert(model->isValid()); 3438 } 3439 3440 inline bool is_ignored_dynamic_output_shape_nchw_quant8_2(int i) { 3441 static std::set<int> ignore = {}; 3442 return ignore.find(i) != ignore.end(); 3443 } 3444 3445 void CreateModel_dynamic_output_shape_nchw_float16_2(Model *model) { 3446 OperandType type0(Type::BOOL, {}); 3447 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 3448 OperandType type12(Type::TENSOR_FLOAT16, {1}); 3449 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 3450 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 3451 OperandType type4(Type::INT32, {}); 3452 // Phase 1, operands 3453 auto op11 = model->addOperand(&type28); 3454 auto op21 = model->addOperand(&type10); 3455 auto op31 = model->addOperand(&type12); 3456 auto param9 = model->addOperand(&type4); 3457 auto param10 = model->addOperand(&type4); 3458 auto param11 = model->addOperand(&type4); 3459 auto param12 = model->addOperand(&type4); 3460 auto param13 = model->addOperand(&type4); 3461 auto param14 = model->addOperand(&type4); 3462 auto param15 = model->addOperand(&type4); 3463 auto layout = model->addOperand(&type0); 3464 auto param16 = model->addOperand(&type4); 3465 auto param17 = model->addOperand(&type4); 3466 auto op41 = model->addOperand(&type21); 3467 // Phase 2, operations 3468 static _Float16 op21_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 3469 model->setOperandValue(op21, op21_init, sizeof(_Float16) * 9); 3470 static _Float16 op31_init[] = {0.0f}; 3471 model->setOperandValue(op31, op31_init, sizeof(_Float16) * 1); 3472 static int32_t param9_init[] = {0}; 3473 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3474 static int32_t param10_init[] = {0}; 3475 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3476 static int32_t param11_init[] = {0}; 3477 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3478 static int32_t param12_init[] = {0}; 3479 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3480 static int32_t param13_init[] = {1}; 3481 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3482 static int32_t param14_init[] = {1}; 3483 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3484 static int32_t param15_init[] = {0}; 3485 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3486 static bool8 layout_init[] = {true}; 3487 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3488 static int32_t param16_init[] = {3}; 3489 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3490 static int32_t param17_init[] = {3}; 3491 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3492 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3493 // Phase 3, inputs and outputs 3494 model->identifyInputsAndOutputs( 3495 {op11}, 3496 {op41}); 3497 assert(model->isValid()); 3498 } 3499 3500 inline bool is_ignored_dynamic_output_shape_nchw_float16_2(int i) { 3501 static std::set<int> ignore = {}; 3502 return ignore.find(i) != ignore.end(); 3503 } 3504 3505 void CreateModel_dynamic_output_shape_nchw_weight_as_input_2(Model *model) { 3506 OperandType type0(Type::BOOL, {}); 3507 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3508 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3509 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 3510 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3511 OperandType type4(Type::INT32, {}); 3512 // Phase 1, operands 3513 auto op11 = model->addOperand(&type25); 3514 auto op21 = model->addOperand(&type1); 3515 auto op31 = model->addOperand(&type3); 3516 auto param9 = model->addOperand(&type4); 3517 auto param10 = model->addOperand(&type4); 3518 auto param11 = model->addOperand(&type4); 3519 auto param12 = model->addOperand(&type4); 3520 auto param13 = model->addOperand(&type4); 3521 auto param14 = model->addOperand(&type4); 3522 auto param15 = model->addOperand(&type4); 3523 auto layout = model->addOperand(&type0); 3524 auto param16 = model->addOperand(&type4); 3525 auto param17 = model->addOperand(&type4); 3526 auto op41 = model->addOperand(&type19); 3527 // Phase 2, operations 3528 static int32_t param9_init[] = {0}; 3529 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3530 static int32_t param10_init[] = {0}; 3531 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3532 static int32_t param11_init[] = {0}; 3533 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3534 static int32_t param12_init[] = {0}; 3535 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3536 static int32_t param13_init[] = {1}; 3537 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3538 static int32_t param14_init[] = {1}; 3539 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3540 static int32_t param15_init[] = {0}; 3541 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3542 static bool8 layout_init[] = {true}; 3543 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3544 static int32_t param16_init[] = {3}; 3545 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3546 static int32_t param17_init[] = {3}; 3547 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3548 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3549 // Phase 3, inputs and outputs 3550 model->identifyInputsAndOutputs( 3551 {op11, op21, op31}, 3552 {op41}); 3553 assert(model->isValid()); 3554 } 3555 3556 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_2(int i) { 3557 static std::set<int> ignore = {}; 3558 return ignore.find(i) != ignore.end(); 3559 } 3560 3561 void CreateModel_dynamic_output_shape_nchw_weight_as_input_relaxed_2(Model *model) { 3562 OperandType type0(Type::BOOL, {}); 3563 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3564 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 3565 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 3566 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3567 OperandType type4(Type::INT32, {}); 3568 // Phase 1, operands 3569 auto op11 = model->addOperand(&type25); 3570 auto op21 = model->addOperand(&type1); 3571 auto op31 = model->addOperand(&type3); 3572 auto param9 = model->addOperand(&type4); 3573 auto param10 = model->addOperand(&type4); 3574 auto param11 = model->addOperand(&type4); 3575 auto param12 = model->addOperand(&type4); 3576 auto param13 = model->addOperand(&type4); 3577 auto param14 = model->addOperand(&type4); 3578 auto param15 = model->addOperand(&type4); 3579 auto layout = model->addOperand(&type0); 3580 auto param16 = model->addOperand(&type4); 3581 auto param17 = model->addOperand(&type4); 3582 auto op41 = model->addOperand(&type19); 3583 // Phase 2, operations 3584 static int32_t param9_init[] = {0}; 3585 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3586 static int32_t param10_init[] = {0}; 3587 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3588 static int32_t param11_init[] = {0}; 3589 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3590 static int32_t param12_init[] = {0}; 3591 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3592 static int32_t param13_init[] = {1}; 3593 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3594 static int32_t param14_init[] = {1}; 3595 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3596 static int32_t param15_init[] = {0}; 3597 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3598 static bool8 layout_init[] = {true}; 3599 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3600 static int32_t param16_init[] = {3}; 3601 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3602 static int32_t param17_init[] = {3}; 3603 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3604 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3605 // Phase 3, inputs and outputs 3606 model->identifyInputsAndOutputs( 3607 {op11, op21, op31}, 3608 {op41}); 3609 // Phase 4: set relaxed execution 3610 model->relaxComputationFloat32toFloat16(true); 3611 assert(model->isValid()); 3612 } 3613 3614 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_relaxed_2(int i) { 3615 static std::set<int> ignore = {}; 3616 return ignore.find(i) != ignore.end(); 3617 } 3618 3619 void CreateModel_dynamic_output_shape_nchw_weight_as_input_quant8_2(Model *model) { 3620 OperandType type0(Type::BOOL, {}); 3621 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 3622 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 3623 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 3624 OperandType type4(Type::INT32, {}); 3625 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 3626 // Phase 1, operands 3627 auto op11 = model->addOperand(&type26); 3628 auto op21 = model->addOperand(&type23); 3629 auto op31 = model->addOperand(&type9); 3630 auto param9 = model->addOperand(&type4); 3631 auto param10 = model->addOperand(&type4); 3632 auto param11 = model->addOperand(&type4); 3633 auto param12 = model->addOperand(&type4); 3634 auto param13 = model->addOperand(&type4); 3635 auto param14 = model->addOperand(&type4); 3636 auto param15 = model->addOperand(&type4); 3637 auto layout = model->addOperand(&type0); 3638 auto param16 = model->addOperand(&type4); 3639 auto param17 = model->addOperand(&type4); 3640 auto op41 = model->addOperand(&type20); 3641 // Phase 2, operations 3642 static int32_t param9_init[] = {0}; 3643 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3644 static int32_t param10_init[] = {0}; 3645 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3646 static int32_t param11_init[] = {0}; 3647 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3648 static int32_t param12_init[] = {0}; 3649 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3650 static int32_t param13_init[] = {1}; 3651 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3652 static int32_t param14_init[] = {1}; 3653 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3654 static int32_t param15_init[] = {0}; 3655 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3656 static bool8 layout_init[] = {true}; 3657 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3658 static int32_t param16_init[] = {3}; 3659 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3660 static int32_t param17_init[] = {3}; 3661 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3662 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3663 // Phase 3, inputs and outputs 3664 model->identifyInputsAndOutputs( 3665 {op11, op21, op31}, 3666 {op41}); 3667 assert(model->isValid()); 3668 } 3669 3670 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_quant8_2(int i) { 3671 static std::set<int> ignore = {}; 3672 return ignore.find(i) != ignore.end(); 3673 } 3674 3675 void CreateModel_dynamic_output_shape_nchw_weight_as_input_float16_2(Model *model) { 3676 OperandType type0(Type::BOOL, {}); 3677 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 3678 OperandType type12(Type::TENSOR_FLOAT16, {1}); 3679 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 3680 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 3681 OperandType type4(Type::INT32, {}); 3682 // Phase 1, operands 3683 auto op11 = model->addOperand(&type28); 3684 auto op21 = model->addOperand(&type10); 3685 auto op31 = model->addOperand(&type12); 3686 auto param9 = model->addOperand(&type4); 3687 auto param10 = model->addOperand(&type4); 3688 auto param11 = model->addOperand(&type4); 3689 auto param12 = model->addOperand(&type4); 3690 auto param13 = model->addOperand(&type4); 3691 auto param14 = model->addOperand(&type4); 3692 auto param15 = model->addOperand(&type4); 3693 auto layout = model->addOperand(&type0); 3694 auto param16 = model->addOperand(&type4); 3695 auto param17 = model->addOperand(&type4); 3696 auto op41 = model->addOperand(&type21); 3697 // Phase 2, operations 3698 static int32_t param9_init[] = {0}; 3699 model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1); 3700 static int32_t param10_init[] = {0}; 3701 model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1); 3702 static int32_t param11_init[] = {0}; 3703 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1); 3704 static int32_t param12_init[] = {0}; 3705 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1); 3706 static int32_t param13_init[] = {1}; 3707 model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1); 3708 static int32_t param14_init[] = {1}; 3709 model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1); 3710 static int32_t param15_init[] = {0}; 3711 model->setOperandValue(param15, param15_init, sizeof(int32_t) * 1); 3712 static bool8 layout_init[] = {true}; 3713 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3714 static int32_t param16_init[] = {3}; 3715 model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1); 3716 static int32_t param17_init[] = {3}; 3717 model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1); 3718 model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param9, param10, param11, param12, param13, param14, param15, layout, param16, param17}, {op41}); 3719 // Phase 3, inputs and outputs 3720 model->identifyInputsAndOutputs( 3721 {op11, op21, op31}, 3722 {op41}); 3723 assert(model->isValid()); 3724 } 3725 3726 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_float16_2(int i) { 3727 static std::set<int> ignore = {}; 3728 return ignore.find(i) != ignore.end(); 3729 } 3730 3731 void CreateModel_nhwc_3(Model *model) { 3732 OperandType type0(Type::BOOL, {}); 3733 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3734 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 3735 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3736 OperandType type4(Type::INT32, {}); 3737 // Phase 1, operands 3738 auto op12 = model->addOperand(&type1); 3739 auto op22 = model->addOperand(&type2); 3740 auto op32 = model->addOperand(&type3); 3741 auto param18 = model->addOperand(&type4); 3742 auto param19 = model->addOperand(&type4); 3743 auto param20 = model->addOperand(&type4); 3744 auto param21 = model->addOperand(&type4); 3745 auto layout = model->addOperand(&type0); 3746 auto param22 = model->addOperand(&type4); 3747 auto param23 = model->addOperand(&type4); 3748 auto op42 = model->addOperand(&type2); 3749 // Phase 2, operations 3750 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 3751 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 3752 static float op32_init[] = {0.0f}; 3753 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 3754 static int32_t param18_init[] = {2}; 3755 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 3756 static int32_t param19_init[] = {1}; 3757 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 3758 static int32_t param20_init[] = {1}; 3759 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 3760 static int32_t param21_init[] = {0}; 3761 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 3762 static bool8 layout_init[] = {false}; 3763 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3764 static int32_t param22_init[] = {1}; 3765 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 3766 static int32_t param23_init[] = {1}; 3767 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 3768 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 3769 // Phase 3, inputs and outputs 3770 model->identifyInputsAndOutputs( 3771 {op12}, 3772 {op42}); 3773 assert(model->isValid()); 3774 } 3775 3776 inline bool is_ignored_nhwc_3(int i) { 3777 static std::set<int> ignore = {}; 3778 return ignore.find(i) != ignore.end(); 3779 } 3780 3781 void CreateModel_nhwc_relaxed_3(Model *model) { 3782 OperandType type0(Type::BOOL, {}); 3783 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3784 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 3785 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3786 OperandType type4(Type::INT32, {}); 3787 // Phase 1, operands 3788 auto op12 = model->addOperand(&type1); 3789 auto op22 = model->addOperand(&type2); 3790 auto op32 = model->addOperand(&type3); 3791 auto param18 = model->addOperand(&type4); 3792 auto param19 = model->addOperand(&type4); 3793 auto param20 = model->addOperand(&type4); 3794 auto param21 = model->addOperand(&type4); 3795 auto layout = model->addOperand(&type0); 3796 auto param22 = model->addOperand(&type4); 3797 auto param23 = model->addOperand(&type4); 3798 auto op42 = model->addOperand(&type2); 3799 // Phase 2, operations 3800 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 3801 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 3802 static float op32_init[] = {0.0f}; 3803 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 3804 static int32_t param18_init[] = {2}; 3805 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 3806 static int32_t param19_init[] = {1}; 3807 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 3808 static int32_t param20_init[] = {1}; 3809 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 3810 static int32_t param21_init[] = {0}; 3811 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 3812 static bool8 layout_init[] = {false}; 3813 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3814 static int32_t param22_init[] = {1}; 3815 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 3816 static int32_t param23_init[] = {1}; 3817 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 3818 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 3819 // Phase 3, inputs and outputs 3820 model->identifyInputsAndOutputs( 3821 {op12}, 3822 {op42}); 3823 // Phase 4: set relaxed execution 3824 model->relaxComputationFloat32toFloat16(true); 3825 assert(model->isValid()); 3826 } 3827 3828 inline bool is_ignored_nhwc_relaxed_3(int i) { 3829 static std::set<int> ignore = {}; 3830 return ignore.find(i) != ignore.end(); 3831 } 3832 3833 void CreateModel_nhwc_quant8_3(Model *model) { 3834 OperandType type0(Type::BOOL, {}); 3835 OperandType type4(Type::INT32, {}); 3836 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 3837 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 3838 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 3839 // Phase 1, operands 3840 auto op12 = model->addOperand(&type7); 3841 auto op22 = model->addOperand(&type8); 3842 auto op32 = model->addOperand(&type9); 3843 auto param18 = model->addOperand(&type4); 3844 auto param19 = model->addOperand(&type4); 3845 auto param20 = model->addOperand(&type4); 3846 auto param21 = model->addOperand(&type4); 3847 auto layout = model->addOperand(&type0); 3848 auto param22 = model->addOperand(&type4); 3849 auto param23 = model->addOperand(&type4); 3850 auto op42 = model->addOperand(&type8); 3851 // Phase 2, operations 3852 static uint8_t op22_init[] = {2, 2, 2, 2}; 3853 model->setOperandValue(op22, op22_init, sizeof(uint8_t) * 4); 3854 static int32_t op32_init[] = {0}; 3855 model->setOperandValue(op32, op32_init, sizeof(int32_t) * 1); 3856 static int32_t param18_init[] = {2}; 3857 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 3858 static int32_t param19_init[] = {1}; 3859 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 3860 static int32_t param20_init[] = {1}; 3861 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 3862 static int32_t param21_init[] = {0}; 3863 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 3864 static bool8 layout_init[] = {false}; 3865 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3866 static int32_t param22_init[] = {1}; 3867 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 3868 static int32_t param23_init[] = {1}; 3869 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 3870 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 3871 // Phase 3, inputs and outputs 3872 model->identifyInputsAndOutputs( 3873 {op12}, 3874 {op42}); 3875 assert(model->isValid()); 3876 } 3877 3878 inline bool is_ignored_nhwc_quant8_3(int i) { 3879 static std::set<int> ignore = {}; 3880 return ignore.find(i) != ignore.end(); 3881 } 3882 3883 void CreateModel_nhwc_float16_3(Model *model) { 3884 OperandType type0(Type::BOOL, {}); 3885 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 3886 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 3887 OperandType type12(Type::TENSOR_FLOAT16, {1}); 3888 OperandType type4(Type::INT32, {}); 3889 // Phase 1, operands 3890 auto op12 = model->addOperand(&type10); 3891 auto op22 = model->addOperand(&type11); 3892 auto op32 = model->addOperand(&type12); 3893 auto param18 = model->addOperand(&type4); 3894 auto param19 = model->addOperand(&type4); 3895 auto param20 = model->addOperand(&type4); 3896 auto param21 = model->addOperand(&type4); 3897 auto layout = model->addOperand(&type0); 3898 auto param22 = model->addOperand(&type4); 3899 auto param23 = model->addOperand(&type4); 3900 auto op42 = model->addOperand(&type11); 3901 // Phase 2, operations 3902 static _Float16 op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 3903 model->setOperandValue(op22, op22_init, sizeof(_Float16) * 4); 3904 static _Float16 op32_init[] = {0.0f}; 3905 model->setOperandValue(op32, op32_init, sizeof(_Float16) * 1); 3906 static int32_t param18_init[] = {2}; 3907 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 3908 static int32_t param19_init[] = {1}; 3909 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 3910 static int32_t param20_init[] = {1}; 3911 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 3912 static int32_t param21_init[] = {0}; 3913 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 3914 static bool8 layout_init[] = {false}; 3915 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3916 static int32_t param22_init[] = {1}; 3917 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 3918 static int32_t param23_init[] = {1}; 3919 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 3920 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 3921 // Phase 3, inputs and outputs 3922 model->identifyInputsAndOutputs( 3923 {op12}, 3924 {op42}); 3925 assert(model->isValid()); 3926 } 3927 3928 inline bool is_ignored_nhwc_float16_3(int i) { 3929 static std::set<int> ignore = {}; 3930 return ignore.find(i) != ignore.end(); 3931 } 3932 3933 void CreateModel_nhwc_weight_as_input_3(Model *model) { 3934 OperandType type0(Type::BOOL, {}); 3935 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3936 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 3937 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3938 OperandType type4(Type::INT32, {}); 3939 // Phase 1, operands 3940 auto op12 = model->addOperand(&type1); 3941 auto op22 = model->addOperand(&type2); 3942 auto op32 = model->addOperand(&type3); 3943 auto param18 = model->addOperand(&type4); 3944 auto param19 = model->addOperand(&type4); 3945 auto param20 = model->addOperand(&type4); 3946 auto param21 = model->addOperand(&type4); 3947 auto layout = model->addOperand(&type0); 3948 auto param22 = model->addOperand(&type4); 3949 auto param23 = model->addOperand(&type4); 3950 auto op42 = model->addOperand(&type2); 3951 // Phase 2, operations 3952 static int32_t param18_init[] = {2}; 3953 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 3954 static int32_t param19_init[] = {1}; 3955 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 3956 static int32_t param20_init[] = {1}; 3957 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 3958 static int32_t param21_init[] = {0}; 3959 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 3960 static bool8 layout_init[] = {false}; 3961 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 3962 static int32_t param22_init[] = {1}; 3963 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 3964 static int32_t param23_init[] = {1}; 3965 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 3966 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 3967 // Phase 3, inputs and outputs 3968 model->identifyInputsAndOutputs( 3969 {op12, op22, op32}, 3970 {op42}); 3971 assert(model->isValid()); 3972 } 3973 3974 inline bool is_ignored_nhwc_weight_as_input_3(int i) { 3975 static std::set<int> ignore = {}; 3976 return ignore.find(i) != ignore.end(); 3977 } 3978 3979 void CreateModel_nhwc_weight_as_input_relaxed_3(Model *model) { 3980 OperandType type0(Type::BOOL, {}); 3981 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 3982 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 3983 OperandType type3(Type::TENSOR_FLOAT32, {1}); 3984 OperandType type4(Type::INT32, {}); 3985 // Phase 1, operands 3986 auto op12 = model->addOperand(&type1); 3987 auto op22 = model->addOperand(&type2); 3988 auto op32 = model->addOperand(&type3); 3989 auto param18 = model->addOperand(&type4); 3990 auto param19 = model->addOperand(&type4); 3991 auto param20 = model->addOperand(&type4); 3992 auto param21 = model->addOperand(&type4); 3993 auto layout = model->addOperand(&type0); 3994 auto param22 = model->addOperand(&type4); 3995 auto param23 = model->addOperand(&type4); 3996 auto op42 = model->addOperand(&type2); 3997 // Phase 2, operations 3998 static int32_t param18_init[] = {2}; 3999 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4000 static int32_t param19_init[] = {1}; 4001 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4002 static int32_t param20_init[] = {1}; 4003 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4004 static int32_t param21_init[] = {0}; 4005 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4006 static bool8 layout_init[] = {false}; 4007 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4008 static int32_t param22_init[] = {1}; 4009 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4010 static int32_t param23_init[] = {1}; 4011 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4012 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4013 // Phase 3, inputs and outputs 4014 model->identifyInputsAndOutputs( 4015 {op12, op22, op32}, 4016 {op42}); 4017 // Phase 4: set relaxed execution 4018 model->relaxComputationFloat32toFloat16(true); 4019 assert(model->isValid()); 4020 } 4021 4022 inline bool is_ignored_nhwc_weight_as_input_relaxed_3(int i) { 4023 static std::set<int> ignore = {}; 4024 return ignore.find(i) != ignore.end(); 4025 } 4026 4027 void CreateModel_nhwc_weight_as_input_quant8_3(Model *model) { 4028 OperandType type0(Type::BOOL, {}); 4029 OperandType type4(Type::INT32, {}); 4030 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 4031 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 4032 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 4033 // Phase 1, operands 4034 auto op12 = model->addOperand(&type7); 4035 auto op22 = model->addOperand(&type8); 4036 auto op32 = model->addOperand(&type9); 4037 auto param18 = model->addOperand(&type4); 4038 auto param19 = model->addOperand(&type4); 4039 auto param20 = model->addOperand(&type4); 4040 auto param21 = model->addOperand(&type4); 4041 auto layout = model->addOperand(&type0); 4042 auto param22 = model->addOperand(&type4); 4043 auto param23 = model->addOperand(&type4); 4044 auto op42 = model->addOperand(&type8); 4045 // Phase 2, operations 4046 static int32_t param18_init[] = {2}; 4047 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4048 static int32_t param19_init[] = {1}; 4049 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4050 static int32_t param20_init[] = {1}; 4051 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4052 static int32_t param21_init[] = {0}; 4053 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4054 static bool8 layout_init[] = {false}; 4055 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4056 static int32_t param22_init[] = {1}; 4057 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4058 static int32_t param23_init[] = {1}; 4059 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4060 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4061 // Phase 3, inputs and outputs 4062 model->identifyInputsAndOutputs( 4063 {op12, op22, op32}, 4064 {op42}); 4065 assert(model->isValid()); 4066 } 4067 4068 inline bool is_ignored_nhwc_weight_as_input_quant8_3(int i) { 4069 static std::set<int> ignore = {}; 4070 return ignore.find(i) != ignore.end(); 4071 } 4072 4073 void CreateModel_nhwc_weight_as_input_float16_3(Model *model) { 4074 OperandType type0(Type::BOOL, {}); 4075 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 4076 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 4077 OperandType type12(Type::TENSOR_FLOAT16, {1}); 4078 OperandType type4(Type::INT32, {}); 4079 // Phase 1, operands 4080 auto op12 = model->addOperand(&type10); 4081 auto op22 = model->addOperand(&type11); 4082 auto op32 = model->addOperand(&type12); 4083 auto param18 = model->addOperand(&type4); 4084 auto param19 = model->addOperand(&type4); 4085 auto param20 = model->addOperand(&type4); 4086 auto param21 = model->addOperand(&type4); 4087 auto layout = model->addOperand(&type0); 4088 auto param22 = model->addOperand(&type4); 4089 auto param23 = model->addOperand(&type4); 4090 auto op42 = model->addOperand(&type11); 4091 // Phase 2, operations 4092 static int32_t param18_init[] = {2}; 4093 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4094 static int32_t param19_init[] = {1}; 4095 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4096 static int32_t param20_init[] = {1}; 4097 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4098 static int32_t param21_init[] = {0}; 4099 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4100 static bool8 layout_init[] = {false}; 4101 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4102 static int32_t param22_init[] = {1}; 4103 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4104 static int32_t param23_init[] = {1}; 4105 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4106 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4107 // Phase 3, inputs and outputs 4108 model->identifyInputsAndOutputs( 4109 {op12, op22, op32}, 4110 {op42}); 4111 assert(model->isValid()); 4112 } 4113 4114 inline bool is_ignored_nhwc_weight_as_input_float16_3(int i) { 4115 static std::set<int> ignore = {}; 4116 return ignore.find(i) != ignore.end(); 4117 } 4118 4119 void CreateModel_nchw_3(Model *model) { 4120 OperandType type0(Type::BOOL, {}); 4121 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4122 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 4123 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4124 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4125 OperandType type4(Type::INT32, {}); 4126 // Phase 1, operands 4127 auto op12 = model->addOperand(&type13); 4128 auto op22 = model->addOperand(&type2); 4129 auto op32 = model->addOperand(&type3); 4130 auto param18 = model->addOperand(&type4); 4131 auto param19 = model->addOperand(&type4); 4132 auto param20 = model->addOperand(&type4); 4133 auto param21 = model->addOperand(&type4); 4134 auto layout = model->addOperand(&type0); 4135 auto param22 = model->addOperand(&type4); 4136 auto param23 = model->addOperand(&type4); 4137 auto op42 = model->addOperand(&type14); 4138 // Phase 2, operations 4139 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4140 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4141 static float op32_init[] = {0.0f}; 4142 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4143 static int32_t param18_init[] = {2}; 4144 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4145 static int32_t param19_init[] = {1}; 4146 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4147 static int32_t param20_init[] = {1}; 4148 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4149 static int32_t param21_init[] = {0}; 4150 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4151 static bool8 layout_init[] = {true}; 4152 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4153 static int32_t param22_init[] = {1}; 4154 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4155 static int32_t param23_init[] = {1}; 4156 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4157 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4158 // Phase 3, inputs and outputs 4159 model->identifyInputsAndOutputs( 4160 {op12}, 4161 {op42}); 4162 assert(model->isValid()); 4163 } 4164 4165 inline bool is_ignored_nchw_3(int i) { 4166 static std::set<int> ignore = {}; 4167 return ignore.find(i) != ignore.end(); 4168 } 4169 4170 void CreateModel_nchw_relaxed_3(Model *model) { 4171 OperandType type0(Type::BOOL, {}); 4172 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4173 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 4174 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4175 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4176 OperandType type4(Type::INT32, {}); 4177 // Phase 1, operands 4178 auto op12 = model->addOperand(&type13); 4179 auto op22 = model->addOperand(&type2); 4180 auto op32 = model->addOperand(&type3); 4181 auto param18 = model->addOperand(&type4); 4182 auto param19 = model->addOperand(&type4); 4183 auto param20 = model->addOperand(&type4); 4184 auto param21 = model->addOperand(&type4); 4185 auto layout = model->addOperand(&type0); 4186 auto param22 = model->addOperand(&type4); 4187 auto param23 = model->addOperand(&type4); 4188 auto op42 = model->addOperand(&type14); 4189 // Phase 2, operations 4190 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4191 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4192 static float op32_init[] = {0.0f}; 4193 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4194 static int32_t param18_init[] = {2}; 4195 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4196 static int32_t param19_init[] = {1}; 4197 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4198 static int32_t param20_init[] = {1}; 4199 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4200 static int32_t param21_init[] = {0}; 4201 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4202 static bool8 layout_init[] = {true}; 4203 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4204 static int32_t param22_init[] = {1}; 4205 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4206 static int32_t param23_init[] = {1}; 4207 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4208 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4209 // Phase 3, inputs and outputs 4210 model->identifyInputsAndOutputs( 4211 {op12}, 4212 {op42}); 4213 // Phase 4: set relaxed execution 4214 model->relaxComputationFloat32toFloat16(true); 4215 assert(model->isValid()); 4216 } 4217 4218 inline bool is_ignored_nchw_relaxed_3(int i) { 4219 static std::set<int> ignore = {}; 4220 return ignore.find(i) != ignore.end(); 4221 } 4222 4223 void CreateModel_nchw_quant8_3(Model *model) { 4224 OperandType type0(Type::BOOL, {}); 4225 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 4226 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {1, 1, 2, 2}, 0.125f, 0); 4227 OperandType type4(Type::INT32, {}); 4228 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 4229 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 4230 // Phase 1, operands 4231 auto op12 = model->addOperand(&type15); 4232 auto op22 = model->addOperand(&type8); 4233 auto op32 = model->addOperand(&type9); 4234 auto param18 = model->addOperand(&type4); 4235 auto param19 = model->addOperand(&type4); 4236 auto param20 = model->addOperand(&type4); 4237 auto param21 = model->addOperand(&type4); 4238 auto layout = model->addOperand(&type0); 4239 auto param22 = model->addOperand(&type4); 4240 auto param23 = model->addOperand(&type4); 4241 auto op42 = model->addOperand(&type16); 4242 // Phase 2, operations 4243 static uint8_t op22_init[] = {2, 2, 2, 2}; 4244 model->setOperandValue(op22, op22_init, sizeof(uint8_t) * 4); 4245 static int32_t op32_init[] = {0}; 4246 model->setOperandValue(op32, op32_init, sizeof(int32_t) * 1); 4247 static int32_t param18_init[] = {2}; 4248 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4249 static int32_t param19_init[] = {1}; 4250 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4251 static int32_t param20_init[] = {1}; 4252 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4253 static int32_t param21_init[] = {0}; 4254 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4255 static bool8 layout_init[] = {true}; 4256 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4257 static int32_t param22_init[] = {1}; 4258 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4259 static int32_t param23_init[] = {1}; 4260 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4261 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4262 // Phase 3, inputs and outputs 4263 model->identifyInputsAndOutputs( 4264 {op12}, 4265 {op42}); 4266 assert(model->isValid()); 4267 } 4268 4269 inline bool is_ignored_nchw_quant8_3(int i) { 4270 static std::set<int> ignore = {}; 4271 return ignore.find(i) != ignore.end(); 4272 } 4273 4274 void CreateModel_nchw_float16_3(Model *model) { 4275 OperandType type0(Type::BOOL, {}); 4276 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 4277 OperandType type12(Type::TENSOR_FLOAT16, {1}); 4278 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 4279 OperandType type18(Type::TENSOR_FLOAT16, {1, 1, 2, 2}); 4280 OperandType type4(Type::INT32, {}); 4281 // Phase 1, operands 4282 auto op12 = model->addOperand(&type17); 4283 auto op22 = model->addOperand(&type11); 4284 auto op32 = model->addOperand(&type12); 4285 auto param18 = model->addOperand(&type4); 4286 auto param19 = model->addOperand(&type4); 4287 auto param20 = model->addOperand(&type4); 4288 auto param21 = model->addOperand(&type4); 4289 auto layout = model->addOperand(&type0); 4290 auto param22 = model->addOperand(&type4); 4291 auto param23 = model->addOperand(&type4); 4292 auto op42 = model->addOperand(&type18); 4293 // Phase 2, operations 4294 static _Float16 op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4295 model->setOperandValue(op22, op22_init, sizeof(_Float16) * 4); 4296 static _Float16 op32_init[] = {0.0f}; 4297 model->setOperandValue(op32, op32_init, sizeof(_Float16) * 1); 4298 static int32_t param18_init[] = {2}; 4299 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4300 static int32_t param19_init[] = {1}; 4301 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4302 static int32_t param20_init[] = {1}; 4303 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4304 static int32_t param21_init[] = {0}; 4305 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4306 static bool8 layout_init[] = {true}; 4307 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4308 static int32_t param22_init[] = {1}; 4309 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4310 static int32_t param23_init[] = {1}; 4311 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4312 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4313 // Phase 3, inputs and outputs 4314 model->identifyInputsAndOutputs( 4315 {op12}, 4316 {op42}); 4317 assert(model->isValid()); 4318 } 4319 4320 inline bool is_ignored_nchw_float16_3(int i) { 4321 static std::set<int> ignore = {}; 4322 return ignore.find(i) != ignore.end(); 4323 } 4324 4325 void CreateModel_nchw_weight_as_input_3(Model *model) { 4326 OperandType type0(Type::BOOL, {}); 4327 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4328 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 4329 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4330 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4331 OperandType type4(Type::INT32, {}); 4332 // Phase 1, operands 4333 auto op12 = model->addOperand(&type13); 4334 auto op22 = model->addOperand(&type2); 4335 auto op32 = model->addOperand(&type3); 4336 auto param18 = model->addOperand(&type4); 4337 auto param19 = model->addOperand(&type4); 4338 auto param20 = model->addOperand(&type4); 4339 auto param21 = model->addOperand(&type4); 4340 auto layout = model->addOperand(&type0); 4341 auto param22 = model->addOperand(&type4); 4342 auto param23 = model->addOperand(&type4); 4343 auto op42 = model->addOperand(&type14); 4344 // Phase 2, operations 4345 static int32_t param18_init[] = {2}; 4346 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4347 static int32_t param19_init[] = {1}; 4348 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4349 static int32_t param20_init[] = {1}; 4350 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4351 static int32_t param21_init[] = {0}; 4352 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4353 static bool8 layout_init[] = {true}; 4354 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4355 static int32_t param22_init[] = {1}; 4356 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4357 static int32_t param23_init[] = {1}; 4358 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4359 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4360 // Phase 3, inputs and outputs 4361 model->identifyInputsAndOutputs( 4362 {op12, op22, op32}, 4363 {op42}); 4364 assert(model->isValid()); 4365 } 4366 4367 inline bool is_ignored_nchw_weight_as_input_3(int i) { 4368 static std::set<int> ignore = {}; 4369 return ignore.find(i) != ignore.end(); 4370 } 4371 4372 void CreateModel_nchw_weight_as_input_relaxed_3(Model *model) { 4373 OperandType type0(Type::BOOL, {}); 4374 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4375 OperandType type14(Type::TENSOR_FLOAT32, {1, 1, 2, 2}); 4376 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4377 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4378 OperandType type4(Type::INT32, {}); 4379 // Phase 1, operands 4380 auto op12 = model->addOperand(&type13); 4381 auto op22 = model->addOperand(&type2); 4382 auto op32 = model->addOperand(&type3); 4383 auto param18 = model->addOperand(&type4); 4384 auto param19 = model->addOperand(&type4); 4385 auto param20 = model->addOperand(&type4); 4386 auto param21 = model->addOperand(&type4); 4387 auto layout = model->addOperand(&type0); 4388 auto param22 = model->addOperand(&type4); 4389 auto param23 = model->addOperand(&type4); 4390 auto op42 = model->addOperand(&type14); 4391 // Phase 2, operations 4392 static int32_t param18_init[] = {2}; 4393 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4394 static int32_t param19_init[] = {1}; 4395 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4396 static int32_t param20_init[] = {1}; 4397 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4398 static int32_t param21_init[] = {0}; 4399 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4400 static bool8 layout_init[] = {true}; 4401 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4402 static int32_t param22_init[] = {1}; 4403 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4404 static int32_t param23_init[] = {1}; 4405 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4406 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4407 // Phase 3, inputs and outputs 4408 model->identifyInputsAndOutputs( 4409 {op12, op22, op32}, 4410 {op42}); 4411 // Phase 4: set relaxed execution 4412 model->relaxComputationFloat32toFloat16(true); 4413 assert(model->isValid()); 4414 } 4415 4416 inline bool is_ignored_nchw_weight_as_input_relaxed_3(int i) { 4417 static std::set<int> ignore = {}; 4418 return ignore.find(i) != ignore.end(); 4419 } 4420 4421 void CreateModel_nchw_weight_as_input_quant8_3(Model *model) { 4422 OperandType type0(Type::BOOL, {}); 4423 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 4424 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {1, 1, 2, 2}, 0.125f, 0); 4425 OperandType type4(Type::INT32, {}); 4426 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 4427 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 4428 // Phase 1, operands 4429 auto op12 = model->addOperand(&type15); 4430 auto op22 = model->addOperand(&type8); 4431 auto op32 = model->addOperand(&type9); 4432 auto param18 = model->addOperand(&type4); 4433 auto param19 = model->addOperand(&type4); 4434 auto param20 = model->addOperand(&type4); 4435 auto param21 = model->addOperand(&type4); 4436 auto layout = model->addOperand(&type0); 4437 auto param22 = model->addOperand(&type4); 4438 auto param23 = model->addOperand(&type4); 4439 auto op42 = model->addOperand(&type16); 4440 // Phase 2, operations 4441 static int32_t param18_init[] = {2}; 4442 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4443 static int32_t param19_init[] = {1}; 4444 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4445 static int32_t param20_init[] = {1}; 4446 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4447 static int32_t param21_init[] = {0}; 4448 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4449 static bool8 layout_init[] = {true}; 4450 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4451 static int32_t param22_init[] = {1}; 4452 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4453 static int32_t param23_init[] = {1}; 4454 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4455 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4456 // Phase 3, inputs and outputs 4457 model->identifyInputsAndOutputs( 4458 {op12, op22, op32}, 4459 {op42}); 4460 assert(model->isValid()); 4461 } 4462 4463 inline bool is_ignored_nchw_weight_as_input_quant8_3(int i) { 4464 static std::set<int> ignore = {}; 4465 return ignore.find(i) != ignore.end(); 4466 } 4467 4468 void CreateModel_nchw_weight_as_input_float16_3(Model *model) { 4469 OperandType type0(Type::BOOL, {}); 4470 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 4471 OperandType type12(Type::TENSOR_FLOAT16, {1}); 4472 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 4473 OperandType type18(Type::TENSOR_FLOAT16, {1, 1, 2, 2}); 4474 OperandType type4(Type::INT32, {}); 4475 // Phase 1, operands 4476 auto op12 = model->addOperand(&type17); 4477 auto op22 = model->addOperand(&type11); 4478 auto op32 = model->addOperand(&type12); 4479 auto param18 = model->addOperand(&type4); 4480 auto param19 = model->addOperand(&type4); 4481 auto param20 = model->addOperand(&type4); 4482 auto param21 = model->addOperand(&type4); 4483 auto layout = model->addOperand(&type0); 4484 auto param22 = model->addOperand(&type4); 4485 auto param23 = model->addOperand(&type4); 4486 auto op42 = model->addOperand(&type18); 4487 // Phase 2, operations 4488 static int32_t param18_init[] = {2}; 4489 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4490 static int32_t param19_init[] = {1}; 4491 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4492 static int32_t param20_init[] = {1}; 4493 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4494 static int32_t param21_init[] = {0}; 4495 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4496 static bool8 layout_init[] = {true}; 4497 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4498 static int32_t param22_init[] = {1}; 4499 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4500 static int32_t param23_init[] = {1}; 4501 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4502 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4503 // Phase 3, inputs and outputs 4504 model->identifyInputsAndOutputs( 4505 {op12, op22, op32}, 4506 {op42}); 4507 assert(model->isValid()); 4508 } 4509 4510 inline bool is_ignored_nchw_weight_as_input_float16_3(int i) { 4511 static std::set<int> ignore = {}; 4512 return ignore.find(i) != ignore.end(); 4513 } 4514 4515 void CreateModel_dynamic_output_shape_nhwc_3(Model *model) { 4516 OperandType type0(Type::BOOL, {}); 4517 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 4518 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4519 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4520 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4521 OperandType type4(Type::INT32, {}); 4522 // Phase 1, operands 4523 auto op12 = model->addOperand(&type1); 4524 auto op22 = model->addOperand(&type2); 4525 auto op32 = model->addOperand(&type3); 4526 auto param18 = model->addOperand(&type4); 4527 auto param19 = model->addOperand(&type4); 4528 auto param20 = model->addOperand(&type4); 4529 auto param21 = model->addOperand(&type4); 4530 auto layout = model->addOperand(&type0); 4531 auto param22 = model->addOperand(&type4); 4532 auto param23 = model->addOperand(&type4); 4533 auto op42 = model->addOperand(&type19); 4534 // Phase 2, operations 4535 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4536 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4537 static float op32_init[] = {0.0f}; 4538 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4539 static int32_t param18_init[] = {2}; 4540 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4541 static int32_t param19_init[] = {1}; 4542 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4543 static int32_t param20_init[] = {1}; 4544 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4545 static int32_t param21_init[] = {0}; 4546 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4547 static bool8 layout_init[] = {false}; 4548 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4549 static int32_t param22_init[] = {1}; 4550 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4551 static int32_t param23_init[] = {1}; 4552 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4553 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4554 // Phase 3, inputs and outputs 4555 model->identifyInputsAndOutputs( 4556 {op12}, 4557 {op42}); 4558 assert(model->isValid()); 4559 } 4560 4561 inline bool is_ignored_dynamic_output_shape_nhwc_3(int i) { 4562 static std::set<int> ignore = {}; 4563 return ignore.find(i) != ignore.end(); 4564 } 4565 4566 void CreateModel_dynamic_output_shape_nhwc_relaxed_3(Model *model) { 4567 OperandType type0(Type::BOOL, {}); 4568 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 4569 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4570 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4571 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4572 OperandType type4(Type::INT32, {}); 4573 // Phase 1, operands 4574 auto op12 = model->addOperand(&type1); 4575 auto op22 = model->addOperand(&type2); 4576 auto op32 = model->addOperand(&type3); 4577 auto param18 = model->addOperand(&type4); 4578 auto param19 = model->addOperand(&type4); 4579 auto param20 = model->addOperand(&type4); 4580 auto param21 = model->addOperand(&type4); 4581 auto layout = model->addOperand(&type0); 4582 auto param22 = model->addOperand(&type4); 4583 auto param23 = model->addOperand(&type4); 4584 auto op42 = model->addOperand(&type19); 4585 // Phase 2, operations 4586 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4587 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4588 static float op32_init[] = {0.0f}; 4589 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4590 static int32_t param18_init[] = {2}; 4591 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4592 static int32_t param19_init[] = {1}; 4593 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4594 static int32_t param20_init[] = {1}; 4595 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4596 static int32_t param21_init[] = {0}; 4597 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4598 static bool8 layout_init[] = {false}; 4599 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4600 static int32_t param22_init[] = {1}; 4601 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4602 static int32_t param23_init[] = {1}; 4603 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4604 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4605 // Phase 3, inputs and outputs 4606 model->identifyInputsAndOutputs( 4607 {op12}, 4608 {op42}); 4609 // Phase 4: set relaxed execution 4610 model->relaxComputationFloat32toFloat16(true); 4611 assert(model->isValid()); 4612 } 4613 4614 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_3(int i) { 4615 static std::set<int> ignore = {}; 4616 return ignore.find(i) != ignore.end(); 4617 } 4618 4619 void CreateModel_dynamic_output_shape_nhwc_quant8_3(Model *model) { 4620 OperandType type0(Type::BOOL, {}); 4621 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 4622 OperandType type4(Type::INT32, {}); 4623 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 4624 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 4625 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 4626 // Phase 1, operands 4627 auto op12 = model->addOperand(&type7); 4628 auto op22 = model->addOperand(&type8); 4629 auto op32 = model->addOperand(&type9); 4630 auto param18 = model->addOperand(&type4); 4631 auto param19 = model->addOperand(&type4); 4632 auto param20 = model->addOperand(&type4); 4633 auto param21 = model->addOperand(&type4); 4634 auto layout = model->addOperand(&type0); 4635 auto param22 = model->addOperand(&type4); 4636 auto param23 = model->addOperand(&type4); 4637 auto op42 = model->addOperand(&type20); 4638 // Phase 2, operations 4639 static uint8_t op22_init[] = {2, 2, 2, 2}; 4640 model->setOperandValue(op22, op22_init, sizeof(uint8_t) * 4); 4641 static int32_t op32_init[] = {0}; 4642 model->setOperandValue(op32, op32_init, sizeof(int32_t) * 1); 4643 static int32_t param18_init[] = {2}; 4644 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4645 static int32_t param19_init[] = {1}; 4646 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4647 static int32_t param20_init[] = {1}; 4648 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4649 static int32_t param21_init[] = {0}; 4650 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4651 static bool8 layout_init[] = {false}; 4652 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4653 static int32_t param22_init[] = {1}; 4654 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4655 static int32_t param23_init[] = {1}; 4656 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4657 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4658 // Phase 3, inputs and outputs 4659 model->identifyInputsAndOutputs( 4660 {op12}, 4661 {op42}); 4662 assert(model->isValid()); 4663 } 4664 4665 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_3(int i) { 4666 static std::set<int> ignore = {}; 4667 return ignore.find(i) != ignore.end(); 4668 } 4669 4670 void CreateModel_dynamic_output_shape_nhwc_float16_3(Model *model) { 4671 OperandType type0(Type::BOOL, {}); 4672 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 4673 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 4674 OperandType type12(Type::TENSOR_FLOAT16, {1}); 4675 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 4676 OperandType type4(Type::INT32, {}); 4677 // Phase 1, operands 4678 auto op12 = model->addOperand(&type10); 4679 auto op22 = model->addOperand(&type11); 4680 auto op32 = model->addOperand(&type12); 4681 auto param18 = model->addOperand(&type4); 4682 auto param19 = model->addOperand(&type4); 4683 auto param20 = model->addOperand(&type4); 4684 auto param21 = model->addOperand(&type4); 4685 auto layout = model->addOperand(&type0); 4686 auto param22 = model->addOperand(&type4); 4687 auto param23 = model->addOperand(&type4); 4688 auto op42 = model->addOperand(&type21); 4689 // Phase 2, operations 4690 static _Float16 op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4691 model->setOperandValue(op22, op22_init, sizeof(_Float16) * 4); 4692 static _Float16 op32_init[] = {0.0f}; 4693 model->setOperandValue(op32, op32_init, sizeof(_Float16) * 1); 4694 static int32_t param18_init[] = {2}; 4695 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4696 static int32_t param19_init[] = {1}; 4697 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4698 static int32_t param20_init[] = {1}; 4699 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4700 static int32_t param21_init[] = {0}; 4701 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4702 static bool8 layout_init[] = {false}; 4703 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4704 static int32_t param22_init[] = {1}; 4705 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4706 static int32_t param23_init[] = {1}; 4707 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4708 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4709 // Phase 3, inputs and outputs 4710 model->identifyInputsAndOutputs( 4711 {op12}, 4712 {op42}); 4713 assert(model->isValid()); 4714 } 4715 4716 inline bool is_ignored_dynamic_output_shape_nhwc_float16_3(int i) { 4717 static std::set<int> ignore = {}; 4718 return ignore.find(i) != ignore.end(); 4719 } 4720 4721 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_3(Model *model) { 4722 OperandType type0(Type::BOOL, {}); 4723 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 4724 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4725 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4726 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4727 OperandType type4(Type::INT32, {}); 4728 // Phase 1, operands 4729 auto op12 = model->addOperand(&type1); 4730 auto op22 = model->addOperand(&type2); 4731 auto op32 = model->addOperand(&type3); 4732 auto param18 = model->addOperand(&type4); 4733 auto param19 = model->addOperand(&type4); 4734 auto param20 = model->addOperand(&type4); 4735 auto param21 = model->addOperand(&type4); 4736 auto layout = model->addOperand(&type0); 4737 auto param22 = model->addOperand(&type4); 4738 auto param23 = model->addOperand(&type4); 4739 auto op42 = model->addOperand(&type19); 4740 // Phase 2, operations 4741 static int32_t param18_init[] = {2}; 4742 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4743 static int32_t param19_init[] = {1}; 4744 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4745 static int32_t param20_init[] = {1}; 4746 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4747 static int32_t param21_init[] = {0}; 4748 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4749 static bool8 layout_init[] = {false}; 4750 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4751 static int32_t param22_init[] = {1}; 4752 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4753 static int32_t param23_init[] = {1}; 4754 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4755 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4756 // Phase 3, inputs and outputs 4757 model->identifyInputsAndOutputs( 4758 {op12, op22, op32}, 4759 {op42}); 4760 assert(model->isValid()); 4761 } 4762 4763 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_3(int i) { 4764 static std::set<int> ignore = {}; 4765 return ignore.find(i) != ignore.end(); 4766 } 4767 4768 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_relaxed_3(Model *model) { 4769 OperandType type0(Type::BOOL, {}); 4770 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 4771 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4772 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4773 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4774 OperandType type4(Type::INT32, {}); 4775 // Phase 1, operands 4776 auto op12 = model->addOperand(&type1); 4777 auto op22 = model->addOperand(&type2); 4778 auto op32 = model->addOperand(&type3); 4779 auto param18 = model->addOperand(&type4); 4780 auto param19 = model->addOperand(&type4); 4781 auto param20 = model->addOperand(&type4); 4782 auto param21 = model->addOperand(&type4); 4783 auto layout = model->addOperand(&type0); 4784 auto param22 = model->addOperand(&type4); 4785 auto param23 = model->addOperand(&type4); 4786 auto op42 = model->addOperand(&type19); 4787 // Phase 2, operations 4788 static int32_t param18_init[] = {2}; 4789 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4790 static int32_t param19_init[] = {1}; 4791 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4792 static int32_t param20_init[] = {1}; 4793 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4794 static int32_t param21_init[] = {0}; 4795 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4796 static bool8 layout_init[] = {false}; 4797 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4798 static int32_t param22_init[] = {1}; 4799 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4800 static int32_t param23_init[] = {1}; 4801 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4802 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4803 // Phase 3, inputs and outputs 4804 model->identifyInputsAndOutputs( 4805 {op12, op22, op32}, 4806 {op42}); 4807 // Phase 4: set relaxed execution 4808 model->relaxComputationFloat32toFloat16(true); 4809 assert(model->isValid()); 4810 } 4811 4812 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_relaxed_3(int i) { 4813 static std::set<int> ignore = {}; 4814 return ignore.find(i) != ignore.end(); 4815 } 4816 4817 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_quant8_3(Model *model) { 4818 OperandType type0(Type::BOOL, {}); 4819 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 4820 OperandType type4(Type::INT32, {}); 4821 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.5f, 0); 4822 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 4823 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 4824 // Phase 1, operands 4825 auto op12 = model->addOperand(&type7); 4826 auto op22 = model->addOperand(&type8); 4827 auto op32 = model->addOperand(&type9); 4828 auto param18 = model->addOperand(&type4); 4829 auto param19 = model->addOperand(&type4); 4830 auto param20 = model->addOperand(&type4); 4831 auto param21 = model->addOperand(&type4); 4832 auto layout = model->addOperand(&type0); 4833 auto param22 = model->addOperand(&type4); 4834 auto param23 = model->addOperand(&type4); 4835 auto op42 = model->addOperand(&type20); 4836 // Phase 2, operations 4837 static int32_t param18_init[] = {2}; 4838 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4839 static int32_t param19_init[] = {1}; 4840 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4841 static int32_t param20_init[] = {1}; 4842 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4843 static int32_t param21_init[] = {0}; 4844 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4845 static bool8 layout_init[] = {false}; 4846 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4847 static int32_t param22_init[] = {1}; 4848 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4849 static int32_t param23_init[] = {1}; 4850 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4851 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4852 // Phase 3, inputs and outputs 4853 model->identifyInputsAndOutputs( 4854 {op12, op22, op32}, 4855 {op42}); 4856 assert(model->isValid()); 4857 } 4858 4859 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_quant8_3(int i) { 4860 static std::set<int> ignore = {}; 4861 return ignore.find(i) != ignore.end(); 4862 } 4863 4864 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_float16_3(Model *model) { 4865 OperandType type0(Type::BOOL, {}); 4866 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 4867 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 4868 OperandType type12(Type::TENSOR_FLOAT16, {1}); 4869 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 4870 OperandType type4(Type::INT32, {}); 4871 // Phase 1, operands 4872 auto op12 = model->addOperand(&type10); 4873 auto op22 = model->addOperand(&type11); 4874 auto op32 = model->addOperand(&type12); 4875 auto param18 = model->addOperand(&type4); 4876 auto param19 = model->addOperand(&type4); 4877 auto param20 = model->addOperand(&type4); 4878 auto param21 = model->addOperand(&type4); 4879 auto layout = model->addOperand(&type0); 4880 auto param22 = model->addOperand(&type4); 4881 auto param23 = model->addOperand(&type4); 4882 auto op42 = model->addOperand(&type21); 4883 // Phase 2, operations 4884 static int32_t param18_init[] = {2}; 4885 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4886 static int32_t param19_init[] = {1}; 4887 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4888 static int32_t param20_init[] = {1}; 4889 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4890 static int32_t param21_init[] = {0}; 4891 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4892 static bool8 layout_init[] = {false}; 4893 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4894 static int32_t param22_init[] = {1}; 4895 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4896 static int32_t param23_init[] = {1}; 4897 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4898 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4899 // Phase 3, inputs and outputs 4900 model->identifyInputsAndOutputs( 4901 {op12, op22, op32}, 4902 {op42}); 4903 assert(model->isValid()); 4904 } 4905 4906 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_float16_3(int i) { 4907 static std::set<int> ignore = {}; 4908 return ignore.find(i) != ignore.end(); 4909 } 4910 4911 void CreateModel_dynamic_output_shape_nchw_3(Model *model) { 4912 OperandType type0(Type::BOOL, {}); 4913 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4914 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4915 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4916 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4917 OperandType type4(Type::INT32, {}); 4918 // Phase 1, operands 4919 auto op12 = model->addOperand(&type13); 4920 auto op22 = model->addOperand(&type2); 4921 auto op32 = model->addOperand(&type3); 4922 auto param18 = model->addOperand(&type4); 4923 auto param19 = model->addOperand(&type4); 4924 auto param20 = model->addOperand(&type4); 4925 auto param21 = model->addOperand(&type4); 4926 auto layout = model->addOperand(&type0); 4927 auto param22 = model->addOperand(&type4); 4928 auto param23 = model->addOperand(&type4); 4929 auto op42 = model->addOperand(&type19); 4930 // Phase 2, operations 4931 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4932 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4933 static float op32_init[] = {0.0f}; 4934 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4935 static int32_t param18_init[] = {2}; 4936 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4937 static int32_t param19_init[] = {1}; 4938 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4939 static int32_t param20_init[] = {1}; 4940 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4941 static int32_t param21_init[] = {0}; 4942 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4943 static bool8 layout_init[] = {true}; 4944 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4945 static int32_t param22_init[] = {1}; 4946 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4947 static int32_t param23_init[] = {1}; 4948 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 4949 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 4950 // Phase 3, inputs and outputs 4951 model->identifyInputsAndOutputs( 4952 {op12}, 4953 {op42}); 4954 assert(model->isValid()); 4955 } 4956 4957 inline bool is_ignored_dynamic_output_shape_nchw_3(int i) { 4958 static std::set<int> ignore = {}; 4959 return ignore.find(i) != ignore.end(); 4960 } 4961 4962 void CreateModel_dynamic_output_shape_nchw_relaxed_3(Model *model) { 4963 OperandType type0(Type::BOOL, {}); 4964 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 4965 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 4966 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 4967 OperandType type3(Type::TENSOR_FLOAT32, {1}); 4968 OperandType type4(Type::INT32, {}); 4969 // Phase 1, operands 4970 auto op12 = model->addOperand(&type13); 4971 auto op22 = model->addOperand(&type2); 4972 auto op32 = model->addOperand(&type3); 4973 auto param18 = model->addOperand(&type4); 4974 auto param19 = model->addOperand(&type4); 4975 auto param20 = model->addOperand(&type4); 4976 auto param21 = model->addOperand(&type4); 4977 auto layout = model->addOperand(&type0); 4978 auto param22 = model->addOperand(&type4); 4979 auto param23 = model->addOperand(&type4); 4980 auto op42 = model->addOperand(&type19); 4981 // Phase 2, operations 4982 static float op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 4983 model->setOperandValue(op22, op22_init, sizeof(float) * 4); 4984 static float op32_init[] = {0.0f}; 4985 model->setOperandValue(op32, op32_init, sizeof(float) * 1); 4986 static int32_t param18_init[] = {2}; 4987 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 4988 static int32_t param19_init[] = {1}; 4989 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 4990 static int32_t param20_init[] = {1}; 4991 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 4992 static int32_t param21_init[] = {0}; 4993 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 4994 static bool8 layout_init[] = {true}; 4995 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 4996 static int32_t param22_init[] = {1}; 4997 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 4998 static int32_t param23_init[] = {1}; 4999 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5000 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5001 // Phase 3, inputs and outputs 5002 model->identifyInputsAndOutputs( 5003 {op12}, 5004 {op42}); 5005 // Phase 4: set relaxed execution 5006 model->relaxComputationFloat32toFloat16(true); 5007 assert(model->isValid()); 5008 } 5009 5010 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_3(int i) { 5011 static std::set<int> ignore = {}; 5012 return ignore.find(i) != ignore.end(); 5013 } 5014 5015 void CreateModel_dynamic_output_shape_nchw_quant8_3(Model *model) { 5016 OperandType type0(Type::BOOL, {}); 5017 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 5018 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 5019 OperandType type4(Type::INT32, {}); 5020 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 5021 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 5022 // Phase 1, operands 5023 auto op12 = model->addOperand(&type15); 5024 auto op22 = model->addOperand(&type8); 5025 auto op32 = model->addOperand(&type9); 5026 auto param18 = model->addOperand(&type4); 5027 auto param19 = model->addOperand(&type4); 5028 auto param20 = model->addOperand(&type4); 5029 auto param21 = model->addOperand(&type4); 5030 auto layout = model->addOperand(&type0); 5031 auto param22 = model->addOperand(&type4); 5032 auto param23 = model->addOperand(&type4); 5033 auto op42 = model->addOperand(&type20); 5034 // Phase 2, operations 5035 static uint8_t op22_init[] = {2, 2, 2, 2}; 5036 model->setOperandValue(op22, op22_init, sizeof(uint8_t) * 4); 5037 static int32_t op32_init[] = {0}; 5038 model->setOperandValue(op32, op32_init, sizeof(int32_t) * 1); 5039 static int32_t param18_init[] = {2}; 5040 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5041 static int32_t param19_init[] = {1}; 5042 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5043 static int32_t param20_init[] = {1}; 5044 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5045 static int32_t param21_init[] = {0}; 5046 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5047 static bool8 layout_init[] = {true}; 5048 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5049 static int32_t param22_init[] = {1}; 5050 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5051 static int32_t param23_init[] = {1}; 5052 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5053 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5054 // Phase 3, inputs and outputs 5055 model->identifyInputsAndOutputs( 5056 {op12}, 5057 {op42}); 5058 assert(model->isValid()); 5059 } 5060 5061 inline bool is_ignored_dynamic_output_shape_nchw_quant8_3(int i) { 5062 static std::set<int> ignore = {}; 5063 return ignore.find(i) != ignore.end(); 5064 } 5065 5066 void CreateModel_dynamic_output_shape_nchw_float16_3(Model *model) { 5067 OperandType type0(Type::BOOL, {}); 5068 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 5069 OperandType type12(Type::TENSOR_FLOAT16, {1}); 5070 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 5071 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 5072 OperandType type4(Type::INT32, {}); 5073 // Phase 1, operands 5074 auto op12 = model->addOperand(&type17); 5075 auto op22 = model->addOperand(&type11); 5076 auto op32 = model->addOperand(&type12); 5077 auto param18 = model->addOperand(&type4); 5078 auto param19 = model->addOperand(&type4); 5079 auto param20 = model->addOperand(&type4); 5080 auto param21 = model->addOperand(&type4); 5081 auto layout = model->addOperand(&type0); 5082 auto param22 = model->addOperand(&type4); 5083 auto param23 = model->addOperand(&type4); 5084 auto op42 = model->addOperand(&type21); 5085 // Phase 2, operations 5086 static _Float16 op22_init[] = {0.25f, 0.25f, 0.25f, 0.25f}; 5087 model->setOperandValue(op22, op22_init, sizeof(_Float16) * 4); 5088 static _Float16 op32_init[] = {0.0f}; 5089 model->setOperandValue(op32, op32_init, sizeof(_Float16) * 1); 5090 static int32_t param18_init[] = {2}; 5091 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5092 static int32_t param19_init[] = {1}; 5093 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5094 static int32_t param20_init[] = {1}; 5095 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5096 static int32_t param21_init[] = {0}; 5097 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5098 static bool8 layout_init[] = {true}; 5099 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5100 static int32_t param22_init[] = {1}; 5101 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5102 static int32_t param23_init[] = {1}; 5103 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5104 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5105 // Phase 3, inputs and outputs 5106 model->identifyInputsAndOutputs( 5107 {op12}, 5108 {op42}); 5109 assert(model->isValid()); 5110 } 5111 5112 inline bool is_ignored_dynamic_output_shape_nchw_float16_3(int i) { 5113 static std::set<int> ignore = {}; 5114 return ignore.find(i) != ignore.end(); 5115 } 5116 5117 void CreateModel_dynamic_output_shape_nchw_weight_as_input_3(Model *model) { 5118 OperandType type0(Type::BOOL, {}); 5119 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5120 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 5121 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 5122 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5123 OperandType type4(Type::INT32, {}); 5124 // Phase 1, operands 5125 auto op12 = model->addOperand(&type13); 5126 auto op22 = model->addOperand(&type2); 5127 auto op32 = model->addOperand(&type3); 5128 auto param18 = model->addOperand(&type4); 5129 auto param19 = model->addOperand(&type4); 5130 auto param20 = model->addOperand(&type4); 5131 auto param21 = model->addOperand(&type4); 5132 auto layout = model->addOperand(&type0); 5133 auto param22 = model->addOperand(&type4); 5134 auto param23 = model->addOperand(&type4); 5135 auto op42 = model->addOperand(&type19); 5136 // Phase 2, operations 5137 static int32_t param18_init[] = {2}; 5138 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5139 static int32_t param19_init[] = {1}; 5140 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5141 static int32_t param20_init[] = {1}; 5142 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5143 static int32_t param21_init[] = {0}; 5144 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5145 static bool8 layout_init[] = {true}; 5146 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5147 static int32_t param22_init[] = {1}; 5148 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5149 static int32_t param23_init[] = {1}; 5150 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5151 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5152 // Phase 3, inputs and outputs 5153 model->identifyInputsAndOutputs( 5154 {op12, op22, op32}, 5155 {op42}); 5156 assert(model->isValid()); 5157 } 5158 5159 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_3(int i) { 5160 static std::set<int> ignore = {}; 5161 return ignore.find(i) != ignore.end(); 5162 } 5163 5164 void CreateModel_dynamic_output_shape_nchw_weight_as_input_relaxed_3(Model *model) { 5165 OperandType type0(Type::BOOL, {}); 5166 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5167 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 5168 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 5169 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5170 OperandType type4(Type::INT32, {}); 5171 // Phase 1, operands 5172 auto op12 = model->addOperand(&type13); 5173 auto op22 = model->addOperand(&type2); 5174 auto op32 = model->addOperand(&type3); 5175 auto param18 = model->addOperand(&type4); 5176 auto param19 = model->addOperand(&type4); 5177 auto param20 = model->addOperand(&type4); 5178 auto param21 = model->addOperand(&type4); 5179 auto layout = model->addOperand(&type0); 5180 auto param22 = model->addOperand(&type4); 5181 auto param23 = model->addOperand(&type4); 5182 auto op42 = model->addOperand(&type19); 5183 // Phase 2, operations 5184 static int32_t param18_init[] = {2}; 5185 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5186 static int32_t param19_init[] = {1}; 5187 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5188 static int32_t param20_init[] = {1}; 5189 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5190 static int32_t param21_init[] = {0}; 5191 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5192 static bool8 layout_init[] = {true}; 5193 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5194 static int32_t param22_init[] = {1}; 5195 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5196 static int32_t param23_init[] = {1}; 5197 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5198 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5199 // Phase 3, inputs and outputs 5200 model->identifyInputsAndOutputs( 5201 {op12, op22, op32}, 5202 {op42}); 5203 // Phase 4: set relaxed execution 5204 model->relaxComputationFloat32toFloat16(true); 5205 assert(model->isValid()); 5206 } 5207 5208 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_relaxed_3(int i) { 5209 static std::set<int> ignore = {}; 5210 return ignore.find(i) != ignore.end(); 5211 } 5212 5213 void CreateModel_dynamic_output_shape_nchw_weight_as_input_quant8_3(Model *model) { 5214 OperandType type0(Type::BOOL, {}); 5215 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.5f, 0); 5216 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 5217 OperandType type4(Type::INT32, {}); 5218 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 5219 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 5220 // Phase 1, operands 5221 auto op12 = model->addOperand(&type15); 5222 auto op22 = model->addOperand(&type8); 5223 auto op32 = model->addOperand(&type9); 5224 auto param18 = model->addOperand(&type4); 5225 auto param19 = model->addOperand(&type4); 5226 auto param20 = model->addOperand(&type4); 5227 auto param21 = model->addOperand(&type4); 5228 auto layout = model->addOperand(&type0); 5229 auto param22 = model->addOperand(&type4); 5230 auto param23 = model->addOperand(&type4); 5231 auto op42 = model->addOperand(&type20); 5232 // Phase 2, operations 5233 static int32_t param18_init[] = {2}; 5234 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5235 static int32_t param19_init[] = {1}; 5236 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5237 static int32_t param20_init[] = {1}; 5238 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5239 static int32_t param21_init[] = {0}; 5240 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5241 static bool8 layout_init[] = {true}; 5242 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5243 static int32_t param22_init[] = {1}; 5244 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5245 static int32_t param23_init[] = {1}; 5246 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5247 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5248 // Phase 3, inputs and outputs 5249 model->identifyInputsAndOutputs( 5250 {op12, op22, op32}, 5251 {op42}); 5252 assert(model->isValid()); 5253 } 5254 5255 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_quant8_3(int i) { 5256 static std::set<int> ignore = {}; 5257 return ignore.find(i) != ignore.end(); 5258 } 5259 5260 void CreateModel_dynamic_output_shape_nchw_weight_as_input_float16_3(Model *model) { 5261 OperandType type0(Type::BOOL, {}); 5262 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 5263 OperandType type12(Type::TENSOR_FLOAT16, {1}); 5264 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 5265 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 5266 OperandType type4(Type::INT32, {}); 5267 // Phase 1, operands 5268 auto op12 = model->addOperand(&type17); 5269 auto op22 = model->addOperand(&type11); 5270 auto op32 = model->addOperand(&type12); 5271 auto param18 = model->addOperand(&type4); 5272 auto param19 = model->addOperand(&type4); 5273 auto param20 = model->addOperand(&type4); 5274 auto param21 = model->addOperand(&type4); 5275 auto layout = model->addOperand(&type0); 5276 auto param22 = model->addOperand(&type4); 5277 auto param23 = model->addOperand(&type4); 5278 auto op42 = model->addOperand(&type21); 5279 // Phase 2, operations 5280 static int32_t param18_init[] = {2}; 5281 model->setOperandValue(param18, param18_init, sizeof(int32_t) * 1); 5282 static int32_t param19_init[] = {1}; 5283 model->setOperandValue(param19, param19_init, sizeof(int32_t) * 1); 5284 static int32_t param20_init[] = {1}; 5285 model->setOperandValue(param20, param20_init, sizeof(int32_t) * 1); 5286 static int32_t param21_init[] = {0}; 5287 model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1); 5288 static bool8 layout_init[] = {true}; 5289 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5290 static int32_t param22_init[] = {1}; 5291 model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1); 5292 static int32_t param23_init[] = {1}; 5293 model->setOperandValue(param23, param23_init, sizeof(int32_t) * 1); 5294 model->addOperation(ANEURALNETWORKS_CONV_2D, {op12, op22, op32, param18, param19, param20, param21, layout, param22, param23}, {op42}); 5295 // Phase 3, inputs and outputs 5296 model->identifyInputsAndOutputs( 5297 {op12, op22, op32}, 5298 {op42}); 5299 assert(model->isValid()); 5300 } 5301 5302 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_float16_3(int i) { 5303 static std::set<int> ignore = {}; 5304 return ignore.find(i) != ignore.end(); 5305 } 5306 5307 void CreateModel_nhwc_4(Model *model) { 5308 OperandType type0(Type::BOOL, {}); 5309 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5310 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5311 OperandType type4(Type::INT32, {}); 5312 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 5313 // Phase 1, operands 5314 auto op13 = model->addOperand(&type5); 5315 auto op23 = model->addOperand(&type1); 5316 auto op33 = model->addOperand(&type3); 5317 auto param24 = model->addOperand(&type4); 5318 auto param25 = model->addOperand(&type4); 5319 auto param26 = model->addOperand(&type4); 5320 auto param27 = model->addOperand(&type4); 5321 auto layout = model->addOperand(&type0); 5322 auto param28 = model->addOperand(&type4); 5323 auto param29 = model->addOperand(&type4); 5324 auto op43 = model->addOperand(&type1); 5325 // Phase 2, operations 5326 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5327 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 5328 static float op33_init[] = {0.0f}; 5329 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 5330 static int32_t param24_init[] = {2}; 5331 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5332 static int32_t param25_init[] = {1}; 5333 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5334 static int32_t param26_init[] = {1}; 5335 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5336 static int32_t param27_init[] = {0}; 5337 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5338 static bool8 layout_init[] = {false}; 5339 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5340 static int32_t param28_init[] = {3}; 5341 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5342 static int32_t param29_init[] = {3}; 5343 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5344 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5345 // Phase 3, inputs and outputs 5346 model->identifyInputsAndOutputs( 5347 {op13}, 5348 {op43}); 5349 assert(model->isValid()); 5350 } 5351 5352 inline bool is_ignored_nhwc_4(int i) { 5353 static std::set<int> ignore = {}; 5354 return ignore.find(i) != ignore.end(); 5355 } 5356 5357 void CreateModel_nhwc_relaxed_4(Model *model) { 5358 OperandType type0(Type::BOOL, {}); 5359 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5360 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5361 OperandType type4(Type::INT32, {}); 5362 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 5363 // Phase 1, operands 5364 auto op13 = model->addOperand(&type5); 5365 auto op23 = model->addOperand(&type1); 5366 auto op33 = model->addOperand(&type3); 5367 auto param24 = model->addOperand(&type4); 5368 auto param25 = model->addOperand(&type4); 5369 auto param26 = model->addOperand(&type4); 5370 auto param27 = model->addOperand(&type4); 5371 auto layout = model->addOperand(&type0); 5372 auto param28 = model->addOperand(&type4); 5373 auto param29 = model->addOperand(&type4); 5374 auto op43 = model->addOperand(&type1); 5375 // Phase 2, operations 5376 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5377 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 5378 static float op33_init[] = {0.0f}; 5379 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 5380 static int32_t param24_init[] = {2}; 5381 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5382 static int32_t param25_init[] = {1}; 5383 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5384 static int32_t param26_init[] = {1}; 5385 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5386 static int32_t param27_init[] = {0}; 5387 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5388 static bool8 layout_init[] = {false}; 5389 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5390 static int32_t param28_init[] = {3}; 5391 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5392 static int32_t param29_init[] = {3}; 5393 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5394 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5395 // Phase 3, inputs and outputs 5396 model->identifyInputsAndOutputs( 5397 {op13}, 5398 {op43}); 5399 // Phase 4: set relaxed execution 5400 model->relaxComputationFloat32toFloat16(true); 5401 assert(model->isValid()); 5402 } 5403 5404 inline bool is_ignored_nhwc_relaxed_4(int i) { 5405 static std::set<int> ignore = {}; 5406 return ignore.find(i) != ignore.end(); 5407 } 5408 5409 void CreateModel_nhwc_quant8_4(Model *model) { 5410 OperandType type0(Type::BOOL, {}); 5411 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 5412 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 5413 OperandType type4(Type::INT32, {}); 5414 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 5415 // Phase 1, operands 5416 auto op13 = model->addOperand(&type22); 5417 auto op23 = model->addOperand(&type23); 5418 auto op33 = model->addOperand(&type9); 5419 auto param24 = model->addOperand(&type4); 5420 auto param25 = model->addOperand(&type4); 5421 auto param26 = model->addOperand(&type4); 5422 auto param27 = model->addOperand(&type4); 5423 auto layout = model->addOperand(&type0); 5424 auto param28 = model->addOperand(&type4); 5425 auto param29 = model->addOperand(&type4); 5426 auto op43 = model->addOperand(&type23); 5427 // Phase 2, operations 5428 static uint8_t op23_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 5429 model->setOperandValue(op23, op23_init, sizeof(uint8_t) * 9); 5430 static int32_t op33_init[] = {0}; 5431 model->setOperandValue(op33, op33_init, sizeof(int32_t) * 1); 5432 static int32_t param24_init[] = {2}; 5433 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5434 static int32_t param25_init[] = {1}; 5435 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5436 static int32_t param26_init[] = {1}; 5437 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5438 static int32_t param27_init[] = {0}; 5439 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5440 static bool8 layout_init[] = {false}; 5441 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5442 static int32_t param28_init[] = {3}; 5443 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5444 static int32_t param29_init[] = {3}; 5445 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5446 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5447 // Phase 3, inputs and outputs 5448 model->identifyInputsAndOutputs( 5449 {op13}, 5450 {op43}); 5451 assert(model->isValid()); 5452 } 5453 5454 inline bool is_ignored_nhwc_quant8_4(int i) { 5455 static std::set<int> ignore = {}; 5456 return ignore.find(i) != ignore.end(); 5457 } 5458 5459 void CreateModel_nhwc_float16_4(Model *model) { 5460 OperandType type0(Type::BOOL, {}); 5461 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 5462 OperandType type12(Type::TENSOR_FLOAT16, {1}); 5463 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 5464 OperandType type4(Type::INT32, {}); 5465 // Phase 1, operands 5466 auto op13 = model->addOperand(&type24); 5467 auto op23 = model->addOperand(&type10); 5468 auto op33 = model->addOperand(&type12); 5469 auto param24 = model->addOperand(&type4); 5470 auto param25 = model->addOperand(&type4); 5471 auto param26 = model->addOperand(&type4); 5472 auto param27 = model->addOperand(&type4); 5473 auto layout = model->addOperand(&type0); 5474 auto param28 = model->addOperand(&type4); 5475 auto param29 = model->addOperand(&type4); 5476 auto op43 = model->addOperand(&type10); 5477 // Phase 2, operations 5478 static _Float16 op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5479 model->setOperandValue(op23, op23_init, sizeof(_Float16) * 9); 5480 static _Float16 op33_init[] = {0.0f}; 5481 model->setOperandValue(op33, op33_init, sizeof(_Float16) * 1); 5482 static int32_t param24_init[] = {2}; 5483 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5484 static int32_t param25_init[] = {1}; 5485 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5486 static int32_t param26_init[] = {1}; 5487 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5488 static int32_t param27_init[] = {0}; 5489 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5490 static bool8 layout_init[] = {false}; 5491 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5492 static int32_t param28_init[] = {3}; 5493 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5494 static int32_t param29_init[] = {3}; 5495 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5496 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5497 // Phase 3, inputs and outputs 5498 model->identifyInputsAndOutputs( 5499 {op13}, 5500 {op43}); 5501 assert(model->isValid()); 5502 } 5503 5504 inline bool is_ignored_nhwc_float16_4(int i) { 5505 static std::set<int> ignore = {}; 5506 return ignore.find(i) != ignore.end(); 5507 } 5508 5509 void CreateModel_nhwc_weight_as_input_4(Model *model) { 5510 OperandType type0(Type::BOOL, {}); 5511 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5512 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5513 OperandType type4(Type::INT32, {}); 5514 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 5515 // Phase 1, operands 5516 auto op13 = model->addOperand(&type5); 5517 auto op23 = model->addOperand(&type1); 5518 auto op33 = model->addOperand(&type3); 5519 auto param24 = model->addOperand(&type4); 5520 auto param25 = model->addOperand(&type4); 5521 auto param26 = model->addOperand(&type4); 5522 auto param27 = model->addOperand(&type4); 5523 auto layout = model->addOperand(&type0); 5524 auto param28 = model->addOperand(&type4); 5525 auto param29 = model->addOperand(&type4); 5526 auto op43 = model->addOperand(&type1); 5527 // Phase 2, operations 5528 static int32_t param24_init[] = {2}; 5529 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5530 static int32_t param25_init[] = {1}; 5531 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5532 static int32_t param26_init[] = {1}; 5533 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5534 static int32_t param27_init[] = {0}; 5535 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5536 static bool8 layout_init[] = {false}; 5537 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5538 static int32_t param28_init[] = {3}; 5539 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5540 static int32_t param29_init[] = {3}; 5541 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5542 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5543 // Phase 3, inputs and outputs 5544 model->identifyInputsAndOutputs( 5545 {op13, op23, op33}, 5546 {op43}); 5547 assert(model->isValid()); 5548 } 5549 5550 inline bool is_ignored_nhwc_weight_as_input_4(int i) { 5551 static std::set<int> ignore = {}; 5552 return ignore.find(i) != ignore.end(); 5553 } 5554 5555 void CreateModel_nhwc_weight_as_input_relaxed_4(Model *model) { 5556 OperandType type0(Type::BOOL, {}); 5557 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5558 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5559 OperandType type4(Type::INT32, {}); 5560 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 5561 // Phase 1, operands 5562 auto op13 = model->addOperand(&type5); 5563 auto op23 = model->addOperand(&type1); 5564 auto op33 = model->addOperand(&type3); 5565 auto param24 = model->addOperand(&type4); 5566 auto param25 = model->addOperand(&type4); 5567 auto param26 = model->addOperand(&type4); 5568 auto param27 = model->addOperand(&type4); 5569 auto layout = model->addOperand(&type0); 5570 auto param28 = model->addOperand(&type4); 5571 auto param29 = model->addOperand(&type4); 5572 auto op43 = model->addOperand(&type1); 5573 // Phase 2, operations 5574 static int32_t param24_init[] = {2}; 5575 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5576 static int32_t param25_init[] = {1}; 5577 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5578 static int32_t param26_init[] = {1}; 5579 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5580 static int32_t param27_init[] = {0}; 5581 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5582 static bool8 layout_init[] = {false}; 5583 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5584 static int32_t param28_init[] = {3}; 5585 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5586 static int32_t param29_init[] = {3}; 5587 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5588 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5589 // Phase 3, inputs and outputs 5590 model->identifyInputsAndOutputs( 5591 {op13, op23, op33}, 5592 {op43}); 5593 // Phase 4: set relaxed execution 5594 model->relaxComputationFloat32toFloat16(true); 5595 assert(model->isValid()); 5596 } 5597 5598 inline bool is_ignored_nhwc_weight_as_input_relaxed_4(int i) { 5599 static std::set<int> ignore = {}; 5600 return ignore.find(i) != ignore.end(); 5601 } 5602 5603 void CreateModel_nhwc_weight_as_input_quant8_4(Model *model) { 5604 OperandType type0(Type::BOOL, {}); 5605 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 5606 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 5607 OperandType type4(Type::INT32, {}); 5608 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 5609 // Phase 1, operands 5610 auto op13 = model->addOperand(&type22); 5611 auto op23 = model->addOperand(&type23); 5612 auto op33 = model->addOperand(&type9); 5613 auto param24 = model->addOperand(&type4); 5614 auto param25 = model->addOperand(&type4); 5615 auto param26 = model->addOperand(&type4); 5616 auto param27 = model->addOperand(&type4); 5617 auto layout = model->addOperand(&type0); 5618 auto param28 = model->addOperand(&type4); 5619 auto param29 = model->addOperand(&type4); 5620 auto op43 = model->addOperand(&type23); 5621 // Phase 2, operations 5622 static int32_t param24_init[] = {2}; 5623 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5624 static int32_t param25_init[] = {1}; 5625 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5626 static int32_t param26_init[] = {1}; 5627 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5628 static int32_t param27_init[] = {0}; 5629 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5630 static bool8 layout_init[] = {false}; 5631 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5632 static int32_t param28_init[] = {3}; 5633 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5634 static int32_t param29_init[] = {3}; 5635 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5636 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5637 // Phase 3, inputs and outputs 5638 model->identifyInputsAndOutputs( 5639 {op13, op23, op33}, 5640 {op43}); 5641 assert(model->isValid()); 5642 } 5643 5644 inline bool is_ignored_nhwc_weight_as_input_quant8_4(int i) { 5645 static std::set<int> ignore = {}; 5646 return ignore.find(i) != ignore.end(); 5647 } 5648 5649 void CreateModel_nhwc_weight_as_input_float16_4(Model *model) { 5650 OperandType type0(Type::BOOL, {}); 5651 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 5652 OperandType type12(Type::TENSOR_FLOAT16, {1}); 5653 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 5654 OperandType type4(Type::INT32, {}); 5655 // Phase 1, operands 5656 auto op13 = model->addOperand(&type24); 5657 auto op23 = model->addOperand(&type10); 5658 auto op33 = model->addOperand(&type12); 5659 auto param24 = model->addOperand(&type4); 5660 auto param25 = model->addOperand(&type4); 5661 auto param26 = model->addOperand(&type4); 5662 auto param27 = model->addOperand(&type4); 5663 auto layout = model->addOperand(&type0); 5664 auto param28 = model->addOperand(&type4); 5665 auto param29 = model->addOperand(&type4); 5666 auto op43 = model->addOperand(&type10); 5667 // Phase 2, operations 5668 static int32_t param24_init[] = {2}; 5669 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5670 static int32_t param25_init[] = {1}; 5671 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5672 static int32_t param26_init[] = {1}; 5673 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5674 static int32_t param27_init[] = {0}; 5675 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5676 static bool8 layout_init[] = {false}; 5677 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5678 static int32_t param28_init[] = {3}; 5679 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5680 static int32_t param29_init[] = {3}; 5681 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5682 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5683 // Phase 3, inputs and outputs 5684 model->identifyInputsAndOutputs( 5685 {op13, op23, op33}, 5686 {op43}); 5687 assert(model->isValid()); 5688 } 5689 5690 inline bool is_ignored_nhwc_weight_as_input_float16_4(int i) { 5691 static std::set<int> ignore = {}; 5692 return ignore.find(i) != ignore.end(); 5693 } 5694 5695 void CreateModel_nchw_4(Model *model) { 5696 OperandType type0(Type::BOOL, {}); 5697 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5698 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5699 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 5700 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5701 OperandType type4(Type::INT32, {}); 5702 // Phase 1, operands 5703 auto op13 = model->addOperand(&type25); 5704 auto op23 = model->addOperand(&type1); 5705 auto op33 = model->addOperand(&type3); 5706 auto param24 = model->addOperand(&type4); 5707 auto param25 = model->addOperand(&type4); 5708 auto param26 = model->addOperand(&type4); 5709 auto param27 = model->addOperand(&type4); 5710 auto layout = model->addOperand(&type0); 5711 auto param28 = model->addOperand(&type4); 5712 auto param29 = model->addOperand(&type4); 5713 auto op43 = model->addOperand(&type13); 5714 // Phase 2, operations 5715 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5716 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 5717 static float op33_init[] = {0.0f}; 5718 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 5719 static int32_t param24_init[] = {2}; 5720 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5721 static int32_t param25_init[] = {1}; 5722 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5723 static int32_t param26_init[] = {1}; 5724 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5725 static int32_t param27_init[] = {0}; 5726 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5727 static bool8 layout_init[] = {true}; 5728 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5729 static int32_t param28_init[] = {3}; 5730 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5731 static int32_t param29_init[] = {3}; 5732 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5733 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5734 // Phase 3, inputs and outputs 5735 model->identifyInputsAndOutputs( 5736 {op13}, 5737 {op43}); 5738 assert(model->isValid()); 5739 } 5740 5741 inline bool is_ignored_nchw_4(int i) { 5742 static std::set<int> ignore = {}; 5743 return ignore.find(i) != ignore.end(); 5744 } 5745 5746 void CreateModel_nchw_relaxed_4(Model *model) { 5747 OperandType type0(Type::BOOL, {}); 5748 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5749 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5750 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 5751 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5752 OperandType type4(Type::INT32, {}); 5753 // Phase 1, operands 5754 auto op13 = model->addOperand(&type25); 5755 auto op23 = model->addOperand(&type1); 5756 auto op33 = model->addOperand(&type3); 5757 auto param24 = model->addOperand(&type4); 5758 auto param25 = model->addOperand(&type4); 5759 auto param26 = model->addOperand(&type4); 5760 auto param27 = model->addOperand(&type4); 5761 auto layout = model->addOperand(&type0); 5762 auto param28 = model->addOperand(&type4); 5763 auto param29 = model->addOperand(&type4); 5764 auto op43 = model->addOperand(&type13); 5765 // Phase 2, operations 5766 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5767 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 5768 static float op33_init[] = {0.0f}; 5769 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 5770 static int32_t param24_init[] = {2}; 5771 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5772 static int32_t param25_init[] = {1}; 5773 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5774 static int32_t param26_init[] = {1}; 5775 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5776 static int32_t param27_init[] = {0}; 5777 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5778 static bool8 layout_init[] = {true}; 5779 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5780 static int32_t param28_init[] = {3}; 5781 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5782 static int32_t param29_init[] = {3}; 5783 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5784 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5785 // Phase 3, inputs and outputs 5786 model->identifyInputsAndOutputs( 5787 {op13}, 5788 {op43}); 5789 // Phase 4: set relaxed execution 5790 model->relaxComputationFloat32toFloat16(true); 5791 assert(model->isValid()); 5792 } 5793 5794 inline bool is_ignored_nchw_relaxed_4(int i) { 5795 static std::set<int> ignore = {}; 5796 return ignore.find(i) != ignore.end(); 5797 } 5798 5799 void CreateModel_nchw_quant8_4(Model *model) { 5800 OperandType type0(Type::BOOL, {}); 5801 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 5802 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 5803 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 5804 OperandType type4(Type::INT32, {}); 5805 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 5806 // Phase 1, operands 5807 auto op13 = model->addOperand(&type26); 5808 auto op23 = model->addOperand(&type23); 5809 auto op33 = model->addOperand(&type9); 5810 auto param24 = model->addOperand(&type4); 5811 auto param25 = model->addOperand(&type4); 5812 auto param26 = model->addOperand(&type4); 5813 auto param27 = model->addOperand(&type4); 5814 auto layout = model->addOperand(&type0); 5815 auto param28 = model->addOperand(&type4); 5816 auto param29 = model->addOperand(&type4); 5817 auto op43 = model->addOperand(&type27); 5818 // Phase 2, operations 5819 static uint8_t op23_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 5820 model->setOperandValue(op23, op23_init, sizeof(uint8_t) * 9); 5821 static int32_t op33_init[] = {0}; 5822 model->setOperandValue(op33, op33_init, sizeof(int32_t) * 1); 5823 static int32_t param24_init[] = {2}; 5824 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5825 static int32_t param25_init[] = {1}; 5826 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5827 static int32_t param26_init[] = {1}; 5828 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5829 static int32_t param27_init[] = {0}; 5830 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5831 static bool8 layout_init[] = {true}; 5832 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5833 static int32_t param28_init[] = {3}; 5834 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5835 static int32_t param29_init[] = {3}; 5836 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5837 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5838 // Phase 3, inputs and outputs 5839 model->identifyInputsAndOutputs( 5840 {op13}, 5841 {op43}); 5842 assert(model->isValid()); 5843 } 5844 5845 inline bool is_ignored_nchw_quant8_4(int i) { 5846 static std::set<int> ignore = {}; 5847 return ignore.find(i) != ignore.end(); 5848 } 5849 5850 void CreateModel_nchw_float16_4(Model *model) { 5851 OperandType type0(Type::BOOL, {}); 5852 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 5853 OperandType type12(Type::TENSOR_FLOAT16, {1}); 5854 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 5855 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 5856 OperandType type4(Type::INT32, {}); 5857 // Phase 1, operands 5858 auto op13 = model->addOperand(&type28); 5859 auto op23 = model->addOperand(&type10); 5860 auto op33 = model->addOperand(&type12); 5861 auto param24 = model->addOperand(&type4); 5862 auto param25 = model->addOperand(&type4); 5863 auto param26 = model->addOperand(&type4); 5864 auto param27 = model->addOperand(&type4); 5865 auto layout = model->addOperand(&type0); 5866 auto param28 = model->addOperand(&type4); 5867 auto param29 = model->addOperand(&type4); 5868 auto op43 = model->addOperand(&type17); 5869 // Phase 2, operations 5870 static _Float16 op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 5871 model->setOperandValue(op23, op23_init, sizeof(_Float16) * 9); 5872 static _Float16 op33_init[] = {0.0f}; 5873 model->setOperandValue(op33, op33_init, sizeof(_Float16) * 1); 5874 static int32_t param24_init[] = {2}; 5875 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5876 static int32_t param25_init[] = {1}; 5877 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5878 static int32_t param26_init[] = {1}; 5879 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5880 static int32_t param27_init[] = {0}; 5881 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5882 static bool8 layout_init[] = {true}; 5883 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5884 static int32_t param28_init[] = {3}; 5885 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5886 static int32_t param29_init[] = {3}; 5887 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5888 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5889 // Phase 3, inputs and outputs 5890 model->identifyInputsAndOutputs( 5891 {op13}, 5892 {op43}); 5893 assert(model->isValid()); 5894 } 5895 5896 inline bool is_ignored_nchw_float16_4(int i) { 5897 static std::set<int> ignore = {}; 5898 return ignore.find(i) != ignore.end(); 5899 } 5900 5901 void CreateModel_nchw_weight_as_input_4(Model *model) { 5902 OperandType type0(Type::BOOL, {}); 5903 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5904 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5905 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 5906 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5907 OperandType type4(Type::INT32, {}); 5908 // Phase 1, operands 5909 auto op13 = model->addOperand(&type25); 5910 auto op23 = model->addOperand(&type1); 5911 auto op33 = model->addOperand(&type3); 5912 auto param24 = model->addOperand(&type4); 5913 auto param25 = model->addOperand(&type4); 5914 auto param26 = model->addOperand(&type4); 5915 auto param27 = model->addOperand(&type4); 5916 auto layout = model->addOperand(&type0); 5917 auto param28 = model->addOperand(&type4); 5918 auto param29 = model->addOperand(&type4); 5919 auto op43 = model->addOperand(&type13); 5920 // Phase 2, operations 5921 static int32_t param24_init[] = {2}; 5922 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5923 static int32_t param25_init[] = {1}; 5924 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5925 static int32_t param26_init[] = {1}; 5926 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5927 static int32_t param27_init[] = {0}; 5928 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5929 static bool8 layout_init[] = {true}; 5930 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5931 static int32_t param28_init[] = {3}; 5932 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5933 static int32_t param29_init[] = {3}; 5934 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5935 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5936 // Phase 3, inputs and outputs 5937 model->identifyInputsAndOutputs( 5938 {op13, op23, op33}, 5939 {op43}); 5940 assert(model->isValid()); 5941 } 5942 5943 inline bool is_ignored_nchw_weight_as_input_4(int i) { 5944 static std::set<int> ignore = {}; 5945 return ignore.find(i) != ignore.end(); 5946 } 5947 5948 void CreateModel_nchw_weight_as_input_relaxed_4(Model *model) { 5949 OperandType type0(Type::BOOL, {}); 5950 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 5951 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 5952 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 5953 OperandType type3(Type::TENSOR_FLOAT32, {1}); 5954 OperandType type4(Type::INT32, {}); 5955 // Phase 1, operands 5956 auto op13 = model->addOperand(&type25); 5957 auto op23 = model->addOperand(&type1); 5958 auto op33 = model->addOperand(&type3); 5959 auto param24 = model->addOperand(&type4); 5960 auto param25 = model->addOperand(&type4); 5961 auto param26 = model->addOperand(&type4); 5962 auto param27 = model->addOperand(&type4); 5963 auto layout = model->addOperand(&type0); 5964 auto param28 = model->addOperand(&type4); 5965 auto param29 = model->addOperand(&type4); 5966 auto op43 = model->addOperand(&type13); 5967 // Phase 2, operations 5968 static int32_t param24_init[] = {2}; 5969 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 5970 static int32_t param25_init[] = {1}; 5971 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 5972 static int32_t param26_init[] = {1}; 5973 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 5974 static int32_t param27_init[] = {0}; 5975 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 5976 static bool8 layout_init[] = {true}; 5977 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 5978 static int32_t param28_init[] = {3}; 5979 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 5980 static int32_t param29_init[] = {3}; 5981 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 5982 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 5983 // Phase 3, inputs and outputs 5984 model->identifyInputsAndOutputs( 5985 {op13, op23, op33}, 5986 {op43}); 5987 // Phase 4: set relaxed execution 5988 model->relaxComputationFloat32toFloat16(true); 5989 assert(model->isValid()); 5990 } 5991 5992 inline bool is_ignored_nchw_weight_as_input_relaxed_4(int i) { 5993 static std::set<int> ignore = {}; 5994 return ignore.find(i) != ignore.end(); 5995 } 5996 5997 void CreateModel_nchw_weight_as_input_quant8_4(Model *model) { 5998 OperandType type0(Type::BOOL, {}); 5999 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6000 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 6001 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 6002 OperandType type4(Type::INT32, {}); 6003 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6004 // Phase 1, operands 6005 auto op13 = model->addOperand(&type26); 6006 auto op23 = model->addOperand(&type23); 6007 auto op33 = model->addOperand(&type9); 6008 auto param24 = model->addOperand(&type4); 6009 auto param25 = model->addOperand(&type4); 6010 auto param26 = model->addOperand(&type4); 6011 auto param27 = model->addOperand(&type4); 6012 auto layout = model->addOperand(&type0); 6013 auto param28 = model->addOperand(&type4); 6014 auto param29 = model->addOperand(&type4); 6015 auto op43 = model->addOperand(&type27); 6016 // Phase 2, operations 6017 static int32_t param24_init[] = {2}; 6018 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6019 static int32_t param25_init[] = {1}; 6020 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6021 static int32_t param26_init[] = {1}; 6022 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6023 static int32_t param27_init[] = {0}; 6024 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6025 static bool8 layout_init[] = {true}; 6026 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6027 static int32_t param28_init[] = {3}; 6028 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6029 static int32_t param29_init[] = {3}; 6030 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6031 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6032 // Phase 3, inputs and outputs 6033 model->identifyInputsAndOutputs( 6034 {op13, op23, op33}, 6035 {op43}); 6036 assert(model->isValid()); 6037 } 6038 6039 inline bool is_ignored_nchw_weight_as_input_quant8_4(int i) { 6040 static std::set<int> ignore = {}; 6041 return ignore.find(i) != ignore.end(); 6042 } 6043 6044 void CreateModel_nchw_weight_as_input_float16_4(Model *model) { 6045 OperandType type0(Type::BOOL, {}); 6046 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 6047 OperandType type12(Type::TENSOR_FLOAT16, {1}); 6048 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 6049 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 6050 OperandType type4(Type::INT32, {}); 6051 // Phase 1, operands 6052 auto op13 = model->addOperand(&type28); 6053 auto op23 = model->addOperand(&type10); 6054 auto op33 = model->addOperand(&type12); 6055 auto param24 = model->addOperand(&type4); 6056 auto param25 = model->addOperand(&type4); 6057 auto param26 = model->addOperand(&type4); 6058 auto param27 = model->addOperand(&type4); 6059 auto layout = model->addOperand(&type0); 6060 auto param28 = model->addOperand(&type4); 6061 auto param29 = model->addOperand(&type4); 6062 auto op43 = model->addOperand(&type17); 6063 // Phase 2, operations 6064 static int32_t param24_init[] = {2}; 6065 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6066 static int32_t param25_init[] = {1}; 6067 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6068 static int32_t param26_init[] = {1}; 6069 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6070 static int32_t param27_init[] = {0}; 6071 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6072 static bool8 layout_init[] = {true}; 6073 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6074 static int32_t param28_init[] = {3}; 6075 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6076 static int32_t param29_init[] = {3}; 6077 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6078 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6079 // Phase 3, inputs and outputs 6080 model->identifyInputsAndOutputs( 6081 {op13, op23, op33}, 6082 {op43}); 6083 assert(model->isValid()); 6084 } 6085 6086 inline bool is_ignored_nchw_weight_as_input_float16_4(int i) { 6087 static std::set<int> ignore = {}; 6088 return ignore.find(i) != ignore.end(); 6089 } 6090 6091 void CreateModel_dynamic_output_shape_nhwc_4(Model *model) { 6092 OperandType type0(Type::BOOL, {}); 6093 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6094 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6095 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6096 OperandType type4(Type::INT32, {}); 6097 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 6098 // Phase 1, operands 6099 auto op13 = model->addOperand(&type5); 6100 auto op23 = model->addOperand(&type1); 6101 auto op33 = model->addOperand(&type3); 6102 auto param24 = model->addOperand(&type4); 6103 auto param25 = model->addOperand(&type4); 6104 auto param26 = model->addOperand(&type4); 6105 auto param27 = model->addOperand(&type4); 6106 auto layout = model->addOperand(&type0); 6107 auto param28 = model->addOperand(&type4); 6108 auto param29 = model->addOperand(&type4); 6109 auto op43 = model->addOperand(&type19); 6110 // Phase 2, operations 6111 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6112 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 6113 static float op33_init[] = {0.0f}; 6114 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 6115 static int32_t param24_init[] = {2}; 6116 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6117 static int32_t param25_init[] = {1}; 6118 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6119 static int32_t param26_init[] = {1}; 6120 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6121 static int32_t param27_init[] = {0}; 6122 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6123 static bool8 layout_init[] = {false}; 6124 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6125 static int32_t param28_init[] = {3}; 6126 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6127 static int32_t param29_init[] = {3}; 6128 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6129 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6130 // Phase 3, inputs and outputs 6131 model->identifyInputsAndOutputs( 6132 {op13}, 6133 {op43}); 6134 assert(model->isValid()); 6135 } 6136 6137 inline bool is_ignored_dynamic_output_shape_nhwc_4(int i) { 6138 static std::set<int> ignore = {}; 6139 return ignore.find(i) != ignore.end(); 6140 } 6141 6142 void CreateModel_dynamic_output_shape_nhwc_relaxed_4(Model *model) { 6143 OperandType type0(Type::BOOL, {}); 6144 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6145 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6146 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6147 OperandType type4(Type::INT32, {}); 6148 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 6149 // Phase 1, operands 6150 auto op13 = model->addOperand(&type5); 6151 auto op23 = model->addOperand(&type1); 6152 auto op33 = model->addOperand(&type3); 6153 auto param24 = model->addOperand(&type4); 6154 auto param25 = model->addOperand(&type4); 6155 auto param26 = model->addOperand(&type4); 6156 auto param27 = model->addOperand(&type4); 6157 auto layout = model->addOperand(&type0); 6158 auto param28 = model->addOperand(&type4); 6159 auto param29 = model->addOperand(&type4); 6160 auto op43 = model->addOperand(&type19); 6161 // Phase 2, operations 6162 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6163 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 6164 static float op33_init[] = {0.0f}; 6165 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 6166 static int32_t param24_init[] = {2}; 6167 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6168 static int32_t param25_init[] = {1}; 6169 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6170 static int32_t param26_init[] = {1}; 6171 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6172 static int32_t param27_init[] = {0}; 6173 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6174 static bool8 layout_init[] = {false}; 6175 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6176 static int32_t param28_init[] = {3}; 6177 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6178 static int32_t param29_init[] = {3}; 6179 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6180 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6181 // Phase 3, inputs and outputs 6182 model->identifyInputsAndOutputs( 6183 {op13}, 6184 {op43}); 6185 // Phase 4: set relaxed execution 6186 model->relaxComputationFloat32toFloat16(true); 6187 assert(model->isValid()); 6188 } 6189 6190 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_4(int i) { 6191 static std::set<int> ignore = {}; 6192 return ignore.find(i) != ignore.end(); 6193 } 6194 6195 void CreateModel_dynamic_output_shape_nhwc_quant8_4(Model *model) { 6196 OperandType type0(Type::BOOL, {}); 6197 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 6198 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 6199 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6200 OperandType type4(Type::INT32, {}); 6201 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6202 // Phase 1, operands 6203 auto op13 = model->addOperand(&type22); 6204 auto op23 = model->addOperand(&type23); 6205 auto op33 = model->addOperand(&type9); 6206 auto param24 = model->addOperand(&type4); 6207 auto param25 = model->addOperand(&type4); 6208 auto param26 = model->addOperand(&type4); 6209 auto param27 = model->addOperand(&type4); 6210 auto layout = model->addOperand(&type0); 6211 auto param28 = model->addOperand(&type4); 6212 auto param29 = model->addOperand(&type4); 6213 auto op43 = model->addOperand(&type20); 6214 // Phase 2, operations 6215 static uint8_t op23_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 6216 model->setOperandValue(op23, op23_init, sizeof(uint8_t) * 9); 6217 static int32_t op33_init[] = {0}; 6218 model->setOperandValue(op33, op33_init, sizeof(int32_t) * 1); 6219 static int32_t param24_init[] = {2}; 6220 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6221 static int32_t param25_init[] = {1}; 6222 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6223 static int32_t param26_init[] = {1}; 6224 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6225 static int32_t param27_init[] = {0}; 6226 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6227 static bool8 layout_init[] = {false}; 6228 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6229 static int32_t param28_init[] = {3}; 6230 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6231 static int32_t param29_init[] = {3}; 6232 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6233 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6234 // Phase 3, inputs and outputs 6235 model->identifyInputsAndOutputs( 6236 {op13}, 6237 {op43}); 6238 assert(model->isValid()); 6239 } 6240 6241 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_4(int i) { 6242 static std::set<int> ignore = {}; 6243 return ignore.find(i) != ignore.end(); 6244 } 6245 6246 void CreateModel_dynamic_output_shape_nhwc_float16_4(Model *model) { 6247 OperandType type0(Type::BOOL, {}); 6248 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 6249 OperandType type12(Type::TENSOR_FLOAT16, {1}); 6250 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 6251 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 6252 OperandType type4(Type::INT32, {}); 6253 // Phase 1, operands 6254 auto op13 = model->addOperand(&type24); 6255 auto op23 = model->addOperand(&type10); 6256 auto op33 = model->addOperand(&type12); 6257 auto param24 = model->addOperand(&type4); 6258 auto param25 = model->addOperand(&type4); 6259 auto param26 = model->addOperand(&type4); 6260 auto param27 = model->addOperand(&type4); 6261 auto layout = model->addOperand(&type0); 6262 auto param28 = model->addOperand(&type4); 6263 auto param29 = model->addOperand(&type4); 6264 auto op43 = model->addOperand(&type21); 6265 // Phase 2, operations 6266 static _Float16 op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6267 model->setOperandValue(op23, op23_init, sizeof(_Float16) * 9); 6268 static _Float16 op33_init[] = {0.0f}; 6269 model->setOperandValue(op33, op33_init, sizeof(_Float16) * 1); 6270 static int32_t param24_init[] = {2}; 6271 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6272 static int32_t param25_init[] = {1}; 6273 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6274 static int32_t param26_init[] = {1}; 6275 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6276 static int32_t param27_init[] = {0}; 6277 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6278 static bool8 layout_init[] = {false}; 6279 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6280 static int32_t param28_init[] = {3}; 6281 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6282 static int32_t param29_init[] = {3}; 6283 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6284 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6285 // Phase 3, inputs and outputs 6286 model->identifyInputsAndOutputs( 6287 {op13}, 6288 {op43}); 6289 assert(model->isValid()); 6290 } 6291 6292 inline bool is_ignored_dynamic_output_shape_nhwc_float16_4(int i) { 6293 static std::set<int> ignore = {}; 6294 return ignore.find(i) != ignore.end(); 6295 } 6296 6297 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_4(Model *model) { 6298 OperandType type0(Type::BOOL, {}); 6299 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6300 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6301 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6302 OperandType type4(Type::INT32, {}); 6303 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 6304 // Phase 1, operands 6305 auto op13 = model->addOperand(&type5); 6306 auto op23 = model->addOperand(&type1); 6307 auto op33 = model->addOperand(&type3); 6308 auto param24 = model->addOperand(&type4); 6309 auto param25 = model->addOperand(&type4); 6310 auto param26 = model->addOperand(&type4); 6311 auto param27 = model->addOperand(&type4); 6312 auto layout = model->addOperand(&type0); 6313 auto param28 = model->addOperand(&type4); 6314 auto param29 = model->addOperand(&type4); 6315 auto op43 = model->addOperand(&type19); 6316 // Phase 2, operations 6317 static int32_t param24_init[] = {2}; 6318 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6319 static int32_t param25_init[] = {1}; 6320 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6321 static int32_t param26_init[] = {1}; 6322 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6323 static int32_t param27_init[] = {0}; 6324 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6325 static bool8 layout_init[] = {false}; 6326 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6327 static int32_t param28_init[] = {3}; 6328 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6329 static int32_t param29_init[] = {3}; 6330 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6331 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6332 // Phase 3, inputs and outputs 6333 model->identifyInputsAndOutputs( 6334 {op13, op23, op33}, 6335 {op43}); 6336 assert(model->isValid()); 6337 } 6338 6339 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_4(int i) { 6340 static std::set<int> ignore = {}; 6341 return ignore.find(i) != ignore.end(); 6342 } 6343 6344 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_relaxed_4(Model *model) { 6345 OperandType type0(Type::BOOL, {}); 6346 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6347 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6348 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6349 OperandType type4(Type::INT32, {}); 6350 OperandType type5(Type::TENSOR_FLOAT32, {1, 9, 9, 1}); 6351 // Phase 1, operands 6352 auto op13 = model->addOperand(&type5); 6353 auto op23 = model->addOperand(&type1); 6354 auto op33 = model->addOperand(&type3); 6355 auto param24 = model->addOperand(&type4); 6356 auto param25 = model->addOperand(&type4); 6357 auto param26 = model->addOperand(&type4); 6358 auto param27 = model->addOperand(&type4); 6359 auto layout = model->addOperand(&type0); 6360 auto param28 = model->addOperand(&type4); 6361 auto param29 = model->addOperand(&type4); 6362 auto op43 = model->addOperand(&type19); 6363 // Phase 2, operations 6364 static int32_t param24_init[] = {2}; 6365 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6366 static int32_t param25_init[] = {1}; 6367 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6368 static int32_t param26_init[] = {1}; 6369 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6370 static int32_t param27_init[] = {0}; 6371 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6372 static bool8 layout_init[] = {false}; 6373 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6374 static int32_t param28_init[] = {3}; 6375 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6376 static int32_t param29_init[] = {3}; 6377 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6378 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6379 // Phase 3, inputs and outputs 6380 model->identifyInputsAndOutputs( 6381 {op13, op23, op33}, 6382 {op43}); 6383 // Phase 4: set relaxed execution 6384 model->relaxComputationFloat32toFloat16(true); 6385 assert(model->isValid()); 6386 } 6387 6388 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_relaxed_4(int i) { 6389 static std::set<int> ignore = {}; 6390 return ignore.find(i) != ignore.end(); 6391 } 6392 6393 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_quant8_4(Model *model) { 6394 OperandType type0(Type::BOOL, {}); 6395 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 6396 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 9, 9, 1}, 0.5f, 0); 6397 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6398 OperandType type4(Type::INT32, {}); 6399 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6400 // Phase 1, operands 6401 auto op13 = model->addOperand(&type22); 6402 auto op23 = model->addOperand(&type23); 6403 auto op33 = model->addOperand(&type9); 6404 auto param24 = model->addOperand(&type4); 6405 auto param25 = model->addOperand(&type4); 6406 auto param26 = model->addOperand(&type4); 6407 auto param27 = model->addOperand(&type4); 6408 auto layout = model->addOperand(&type0); 6409 auto param28 = model->addOperand(&type4); 6410 auto param29 = model->addOperand(&type4); 6411 auto op43 = model->addOperand(&type20); 6412 // Phase 2, operations 6413 static int32_t param24_init[] = {2}; 6414 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6415 static int32_t param25_init[] = {1}; 6416 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6417 static int32_t param26_init[] = {1}; 6418 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6419 static int32_t param27_init[] = {0}; 6420 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6421 static bool8 layout_init[] = {false}; 6422 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6423 static int32_t param28_init[] = {3}; 6424 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6425 static int32_t param29_init[] = {3}; 6426 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6427 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6428 // Phase 3, inputs and outputs 6429 model->identifyInputsAndOutputs( 6430 {op13, op23, op33}, 6431 {op43}); 6432 assert(model->isValid()); 6433 } 6434 6435 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_quant8_4(int i) { 6436 static std::set<int> ignore = {}; 6437 return ignore.find(i) != ignore.end(); 6438 } 6439 6440 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_float16_4(Model *model) { 6441 OperandType type0(Type::BOOL, {}); 6442 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 6443 OperandType type12(Type::TENSOR_FLOAT16, {1}); 6444 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 6445 OperandType type24(Type::TENSOR_FLOAT16, {1, 9, 9, 1}); 6446 OperandType type4(Type::INT32, {}); 6447 // Phase 1, operands 6448 auto op13 = model->addOperand(&type24); 6449 auto op23 = model->addOperand(&type10); 6450 auto op33 = model->addOperand(&type12); 6451 auto param24 = model->addOperand(&type4); 6452 auto param25 = model->addOperand(&type4); 6453 auto param26 = model->addOperand(&type4); 6454 auto param27 = model->addOperand(&type4); 6455 auto layout = model->addOperand(&type0); 6456 auto param28 = model->addOperand(&type4); 6457 auto param29 = model->addOperand(&type4); 6458 auto op43 = model->addOperand(&type21); 6459 // Phase 2, operations 6460 static int32_t param24_init[] = {2}; 6461 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6462 static int32_t param25_init[] = {1}; 6463 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6464 static int32_t param26_init[] = {1}; 6465 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6466 static int32_t param27_init[] = {0}; 6467 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6468 static bool8 layout_init[] = {false}; 6469 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6470 static int32_t param28_init[] = {3}; 6471 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6472 static int32_t param29_init[] = {3}; 6473 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6474 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6475 // Phase 3, inputs and outputs 6476 model->identifyInputsAndOutputs( 6477 {op13, op23, op33}, 6478 {op43}); 6479 assert(model->isValid()); 6480 } 6481 6482 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_float16_4(int i) { 6483 static std::set<int> ignore = {}; 6484 return ignore.find(i) != ignore.end(); 6485 } 6486 6487 void CreateModel_dynamic_output_shape_nchw_4(Model *model) { 6488 OperandType type0(Type::BOOL, {}); 6489 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6490 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6491 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 6492 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6493 OperandType type4(Type::INT32, {}); 6494 // Phase 1, operands 6495 auto op13 = model->addOperand(&type25); 6496 auto op23 = model->addOperand(&type1); 6497 auto op33 = model->addOperand(&type3); 6498 auto param24 = model->addOperand(&type4); 6499 auto param25 = model->addOperand(&type4); 6500 auto param26 = model->addOperand(&type4); 6501 auto param27 = model->addOperand(&type4); 6502 auto layout = model->addOperand(&type0); 6503 auto param28 = model->addOperand(&type4); 6504 auto param29 = model->addOperand(&type4); 6505 auto op43 = model->addOperand(&type19); 6506 // Phase 2, operations 6507 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6508 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 6509 static float op33_init[] = {0.0f}; 6510 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 6511 static int32_t param24_init[] = {2}; 6512 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6513 static int32_t param25_init[] = {1}; 6514 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6515 static int32_t param26_init[] = {1}; 6516 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6517 static int32_t param27_init[] = {0}; 6518 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6519 static bool8 layout_init[] = {true}; 6520 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6521 static int32_t param28_init[] = {3}; 6522 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6523 static int32_t param29_init[] = {3}; 6524 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6525 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6526 // Phase 3, inputs and outputs 6527 model->identifyInputsAndOutputs( 6528 {op13}, 6529 {op43}); 6530 assert(model->isValid()); 6531 } 6532 6533 inline bool is_ignored_dynamic_output_shape_nchw_4(int i) { 6534 static std::set<int> ignore = {}; 6535 return ignore.find(i) != ignore.end(); 6536 } 6537 6538 void CreateModel_dynamic_output_shape_nchw_relaxed_4(Model *model) { 6539 OperandType type0(Type::BOOL, {}); 6540 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6541 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6542 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 6543 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6544 OperandType type4(Type::INT32, {}); 6545 // Phase 1, operands 6546 auto op13 = model->addOperand(&type25); 6547 auto op23 = model->addOperand(&type1); 6548 auto op33 = model->addOperand(&type3); 6549 auto param24 = model->addOperand(&type4); 6550 auto param25 = model->addOperand(&type4); 6551 auto param26 = model->addOperand(&type4); 6552 auto param27 = model->addOperand(&type4); 6553 auto layout = model->addOperand(&type0); 6554 auto param28 = model->addOperand(&type4); 6555 auto param29 = model->addOperand(&type4); 6556 auto op43 = model->addOperand(&type19); 6557 // Phase 2, operations 6558 static float op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6559 model->setOperandValue(op23, op23_init, sizeof(float) * 9); 6560 static float op33_init[] = {0.0f}; 6561 model->setOperandValue(op33, op33_init, sizeof(float) * 1); 6562 static int32_t param24_init[] = {2}; 6563 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6564 static int32_t param25_init[] = {1}; 6565 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6566 static int32_t param26_init[] = {1}; 6567 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6568 static int32_t param27_init[] = {0}; 6569 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6570 static bool8 layout_init[] = {true}; 6571 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6572 static int32_t param28_init[] = {3}; 6573 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6574 static int32_t param29_init[] = {3}; 6575 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6576 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6577 // Phase 3, inputs and outputs 6578 model->identifyInputsAndOutputs( 6579 {op13}, 6580 {op43}); 6581 // Phase 4: set relaxed execution 6582 model->relaxComputationFloat32toFloat16(true); 6583 assert(model->isValid()); 6584 } 6585 6586 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_4(int i) { 6587 static std::set<int> ignore = {}; 6588 return ignore.find(i) != ignore.end(); 6589 } 6590 6591 void CreateModel_dynamic_output_shape_nchw_quant8_4(Model *model) { 6592 OperandType type0(Type::BOOL, {}); 6593 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 6594 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6595 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 6596 OperandType type4(Type::INT32, {}); 6597 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6598 // Phase 1, operands 6599 auto op13 = model->addOperand(&type26); 6600 auto op23 = model->addOperand(&type23); 6601 auto op33 = model->addOperand(&type9); 6602 auto param24 = model->addOperand(&type4); 6603 auto param25 = model->addOperand(&type4); 6604 auto param26 = model->addOperand(&type4); 6605 auto param27 = model->addOperand(&type4); 6606 auto layout = model->addOperand(&type0); 6607 auto param28 = model->addOperand(&type4); 6608 auto param29 = model->addOperand(&type4); 6609 auto op43 = model->addOperand(&type20); 6610 // Phase 2, operations 6611 static uint8_t op23_init[] = {8, 16, 24, 32, 40, 48, 56, 64, 72}; 6612 model->setOperandValue(op23, op23_init, sizeof(uint8_t) * 9); 6613 static int32_t op33_init[] = {0}; 6614 model->setOperandValue(op33, op33_init, sizeof(int32_t) * 1); 6615 static int32_t param24_init[] = {2}; 6616 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6617 static int32_t param25_init[] = {1}; 6618 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6619 static int32_t param26_init[] = {1}; 6620 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6621 static int32_t param27_init[] = {0}; 6622 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6623 static bool8 layout_init[] = {true}; 6624 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6625 static int32_t param28_init[] = {3}; 6626 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6627 static int32_t param29_init[] = {3}; 6628 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6629 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6630 // Phase 3, inputs and outputs 6631 model->identifyInputsAndOutputs( 6632 {op13}, 6633 {op43}); 6634 assert(model->isValid()); 6635 } 6636 6637 inline bool is_ignored_dynamic_output_shape_nchw_quant8_4(int i) { 6638 static std::set<int> ignore = {}; 6639 return ignore.find(i) != ignore.end(); 6640 } 6641 6642 void CreateModel_dynamic_output_shape_nchw_float16_4(Model *model) { 6643 OperandType type0(Type::BOOL, {}); 6644 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 6645 OperandType type12(Type::TENSOR_FLOAT16, {1}); 6646 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 6647 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 6648 OperandType type4(Type::INT32, {}); 6649 // Phase 1, operands 6650 auto op13 = model->addOperand(&type28); 6651 auto op23 = model->addOperand(&type10); 6652 auto op33 = model->addOperand(&type12); 6653 auto param24 = model->addOperand(&type4); 6654 auto param25 = model->addOperand(&type4); 6655 auto param26 = model->addOperand(&type4); 6656 auto param27 = model->addOperand(&type4); 6657 auto layout = model->addOperand(&type0); 6658 auto param28 = model->addOperand(&type4); 6659 auto param29 = model->addOperand(&type4); 6660 auto op43 = model->addOperand(&type21); 6661 // Phase 2, operations 6662 static _Float16 op23_init[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f}; 6663 model->setOperandValue(op23, op23_init, sizeof(_Float16) * 9); 6664 static _Float16 op33_init[] = {0.0f}; 6665 model->setOperandValue(op33, op33_init, sizeof(_Float16) * 1); 6666 static int32_t param24_init[] = {2}; 6667 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6668 static int32_t param25_init[] = {1}; 6669 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6670 static int32_t param26_init[] = {1}; 6671 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6672 static int32_t param27_init[] = {0}; 6673 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6674 static bool8 layout_init[] = {true}; 6675 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6676 static int32_t param28_init[] = {3}; 6677 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6678 static int32_t param29_init[] = {3}; 6679 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6680 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6681 // Phase 3, inputs and outputs 6682 model->identifyInputsAndOutputs( 6683 {op13}, 6684 {op43}); 6685 assert(model->isValid()); 6686 } 6687 6688 inline bool is_ignored_dynamic_output_shape_nchw_float16_4(int i) { 6689 static std::set<int> ignore = {}; 6690 return ignore.find(i) != ignore.end(); 6691 } 6692 6693 void CreateModel_dynamic_output_shape_nchw_weight_as_input_4(Model *model) { 6694 OperandType type0(Type::BOOL, {}); 6695 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6696 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6697 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 6698 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6699 OperandType type4(Type::INT32, {}); 6700 // Phase 1, operands 6701 auto op13 = model->addOperand(&type25); 6702 auto op23 = model->addOperand(&type1); 6703 auto op33 = model->addOperand(&type3); 6704 auto param24 = model->addOperand(&type4); 6705 auto param25 = model->addOperand(&type4); 6706 auto param26 = model->addOperand(&type4); 6707 auto param27 = model->addOperand(&type4); 6708 auto layout = model->addOperand(&type0); 6709 auto param28 = model->addOperand(&type4); 6710 auto param29 = model->addOperand(&type4); 6711 auto op43 = model->addOperand(&type19); 6712 // Phase 2, operations 6713 static int32_t param24_init[] = {2}; 6714 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6715 static int32_t param25_init[] = {1}; 6716 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6717 static int32_t param26_init[] = {1}; 6718 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6719 static int32_t param27_init[] = {0}; 6720 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6721 static bool8 layout_init[] = {true}; 6722 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6723 static int32_t param28_init[] = {3}; 6724 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6725 static int32_t param29_init[] = {3}; 6726 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6727 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6728 // Phase 3, inputs and outputs 6729 model->identifyInputsAndOutputs( 6730 {op13, op23, op33}, 6731 {op43}); 6732 assert(model->isValid()); 6733 } 6734 6735 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_4(int i) { 6736 static std::set<int> ignore = {}; 6737 return ignore.find(i) != ignore.end(); 6738 } 6739 6740 void CreateModel_dynamic_output_shape_nchw_weight_as_input_relaxed_4(Model *model) { 6741 OperandType type0(Type::BOOL, {}); 6742 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6743 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 6744 OperandType type25(Type::TENSOR_FLOAT32, {1, 1, 9, 9}); 6745 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6746 OperandType type4(Type::INT32, {}); 6747 // Phase 1, operands 6748 auto op13 = model->addOperand(&type25); 6749 auto op23 = model->addOperand(&type1); 6750 auto op33 = model->addOperand(&type3); 6751 auto param24 = model->addOperand(&type4); 6752 auto param25 = model->addOperand(&type4); 6753 auto param26 = model->addOperand(&type4); 6754 auto param27 = model->addOperand(&type4); 6755 auto layout = model->addOperand(&type0); 6756 auto param28 = model->addOperand(&type4); 6757 auto param29 = model->addOperand(&type4); 6758 auto op43 = model->addOperand(&type19); 6759 // Phase 2, operations 6760 static int32_t param24_init[] = {2}; 6761 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6762 static int32_t param25_init[] = {1}; 6763 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6764 static int32_t param26_init[] = {1}; 6765 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6766 static int32_t param27_init[] = {0}; 6767 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6768 static bool8 layout_init[] = {true}; 6769 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6770 static int32_t param28_init[] = {3}; 6771 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6772 static int32_t param29_init[] = {3}; 6773 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6774 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6775 // Phase 3, inputs and outputs 6776 model->identifyInputsAndOutputs( 6777 {op13, op23, op33}, 6778 {op43}); 6779 // Phase 4: set relaxed execution 6780 model->relaxComputationFloat32toFloat16(true); 6781 assert(model->isValid()); 6782 } 6783 6784 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_relaxed_4(int i) { 6785 static std::set<int> ignore = {}; 6786 return ignore.find(i) != ignore.end(); 6787 } 6788 6789 void CreateModel_dynamic_output_shape_nchw_weight_as_input_quant8_4(Model *model) { 6790 OperandType type0(Type::BOOL, {}); 6791 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 6792 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6793 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {1, 1, 9, 9}, 0.5f, 0); 6794 OperandType type4(Type::INT32, {}); 6795 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6796 // Phase 1, operands 6797 auto op13 = model->addOperand(&type26); 6798 auto op23 = model->addOperand(&type23); 6799 auto op33 = model->addOperand(&type9); 6800 auto param24 = model->addOperand(&type4); 6801 auto param25 = model->addOperand(&type4); 6802 auto param26 = model->addOperand(&type4); 6803 auto param27 = model->addOperand(&type4); 6804 auto layout = model->addOperand(&type0); 6805 auto param28 = model->addOperand(&type4); 6806 auto param29 = model->addOperand(&type4); 6807 auto op43 = model->addOperand(&type20); 6808 // Phase 2, operations 6809 static int32_t param24_init[] = {2}; 6810 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6811 static int32_t param25_init[] = {1}; 6812 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6813 static int32_t param26_init[] = {1}; 6814 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6815 static int32_t param27_init[] = {0}; 6816 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6817 static bool8 layout_init[] = {true}; 6818 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6819 static int32_t param28_init[] = {3}; 6820 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6821 static int32_t param29_init[] = {3}; 6822 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6823 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6824 // Phase 3, inputs and outputs 6825 model->identifyInputsAndOutputs( 6826 {op13, op23, op33}, 6827 {op43}); 6828 assert(model->isValid()); 6829 } 6830 6831 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_quant8_4(int i) { 6832 static std::set<int> ignore = {}; 6833 return ignore.find(i) != ignore.end(); 6834 } 6835 6836 void CreateModel_dynamic_output_shape_nchw_weight_as_input_float16_4(Model *model) { 6837 OperandType type0(Type::BOOL, {}); 6838 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 6839 OperandType type12(Type::TENSOR_FLOAT16, {1}); 6840 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 6841 OperandType type28(Type::TENSOR_FLOAT16, {1, 1, 9, 9}); 6842 OperandType type4(Type::INT32, {}); 6843 // Phase 1, operands 6844 auto op13 = model->addOperand(&type28); 6845 auto op23 = model->addOperand(&type10); 6846 auto op33 = model->addOperand(&type12); 6847 auto param24 = model->addOperand(&type4); 6848 auto param25 = model->addOperand(&type4); 6849 auto param26 = model->addOperand(&type4); 6850 auto param27 = model->addOperand(&type4); 6851 auto layout = model->addOperand(&type0); 6852 auto param28 = model->addOperand(&type4); 6853 auto param29 = model->addOperand(&type4); 6854 auto op43 = model->addOperand(&type21); 6855 // Phase 2, operations 6856 static int32_t param24_init[] = {2}; 6857 model->setOperandValue(param24, param24_init, sizeof(int32_t) * 1); 6858 static int32_t param25_init[] = {1}; 6859 model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1); 6860 static int32_t param26_init[] = {1}; 6861 model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1); 6862 static int32_t param27_init[] = {0}; 6863 model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1); 6864 static bool8 layout_init[] = {true}; 6865 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6866 static int32_t param28_init[] = {3}; 6867 model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1); 6868 static int32_t param29_init[] = {3}; 6869 model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1); 6870 model->addOperation(ANEURALNETWORKS_CONV_2D, {op13, op23, op33, param24, param25, param26, param27, layout, param28, param29}, {op43}); 6871 // Phase 3, inputs and outputs 6872 model->identifyInputsAndOutputs( 6873 {op13, op23, op33}, 6874 {op43}); 6875 assert(model->isValid()); 6876 } 6877 6878 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_float16_4(int i) { 6879 static std::set<int> ignore = {}; 6880 return ignore.find(i) != ignore.end(); 6881 } 6882 6883 void CreateModel_nhwc_5(Model *model) { 6884 OperandType type0(Type::BOOL, {}); 6885 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6886 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 6887 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6888 OperandType type4(Type::INT32, {}); 6889 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 6890 // Phase 1, operands 6891 auto op14 = model->addOperand(&type6); 6892 auto op24 = model->addOperand(&type2); 6893 auto op34 = model->addOperand(&type3); 6894 auto param30 = model->addOperand(&type4); 6895 auto param31 = model->addOperand(&type4); 6896 auto param32 = model->addOperand(&type4); 6897 auto param33 = model->addOperand(&type4); 6898 auto layout = model->addOperand(&type0); 6899 auto param34 = model->addOperand(&type4); 6900 auto param35 = model->addOperand(&type4); 6901 auto op44 = model->addOperand(&type1); 6902 // Phase 2, operations 6903 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 6904 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 6905 static float op34_init[] = {0.0f}; 6906 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 6907 static int32_t param30_init[] = {1}; 6908 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 6909 static int32_t param31_init[] = {2}; 6910 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 6911 static int32_t param32_init[] = {2}; 6912 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 6913 static int32_t param33_init[] = {0}; 6914 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 6915 static bool8 layout_init[] = {false}; 6916 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6917 static int32_t param34_init[] = {3}; 6918 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 6919 static int32_t param35_init[] = {3}; 6920 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 6921 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 6922 // Phase 3, inputs and outputs 6923 model->identifyInputsAndOutputs( 6924 {op14}, 6925 {op44}); 6926 assert(model->isValid()); 6927 } 6928 6929 inline bool is_ignored_nhwc_5(int i) { 6930 static std::set<int> ignore = {}; 6931 return ignore.find(i) != ignore.end(); 6932 } 6933 6934 void CreateModel_nhwc_relaxed_5(Model *model) { 6935 OperandType type0(Type::BOOL, {}); 6936 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 6937 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 6938 OperandType type3(Type::TENSOR_FLOAT32, {1}); 6939 OperandType type4(Type::INT32, {}); 6940 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 6941 // Phase 1, operands 6942 auto op14 = model->addOperand(&type6); 6943 auto op24 = model->addOperand(&type2); 6944 auto op34 = model->addOperand(&type3); 6945 auto param30 = model->addOperand(&type4); 6946 auto param31 = model->addOperand(&type4); 6947 auto param32 = model->addOperand(&type4); 6948 auto param33 = model->addOperand(&type4); 6949 auto layout = model->addOperand(&type0); 6950 auto param34 = model->addOperand(&type4); 6951 auto param35 = model->addOperand(&type4); 6952 auto op44 = model->addOperand(&type1); 6953 // Phase 2, operations 6954 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 6955 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 6956 static float op34_init[] = {0.0f}; 6957 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 6958 static int32_t param30_init[] = {1}; 6959 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 6960 static int32_t param31_init[] = {2}; 6961 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 6962 static int32_t param32_init[] = {2}; 6963 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 6964 static int32_t param33_init[] = {0}; 6965 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 6966 static bool8 layout_init[] = {false}; 6967 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 6968 static int32_t param34_init[] = {3}; 6969 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 6970 static int32_t param35_init[] = {3}; 6971 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 6972 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 6973 // Phase 3, inputs and outputs 6974 model->identifyInputsAndOutputs( 6975 {op14}, 6976 {op44}); 6977 // Phase 4: set relaxed execution 6978 model->relaxComputationFloat32toFloat16(true); 6979 assert(model->isValid()); 6980 } 6981 6982 inline bool is_ignored_nhwc_relaxed_5(int i) { 6983 static std::set<int> ignore = {}; 6984 return ignore.find(i) != ignore.end(); 6985 } 6986 6987 void CreateModel_nhwc_quant8_5(Model *model) { 6988 OperandType type0(Type::BOOL, {}); 6989 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 6990 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {1, 6, 6, 1}, 0.5f, 0); 6991 OperandType type4(Type::INT32, {}); 6992 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 6993 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 6994 // Phase 1, operands 6995 auto op14 = model->addOperand(&type29); 6996 auto op24 = model->addOperand(&type8); 6997 auto op34 = model->addOperand(&type9); 6998 auto param30 = model->addOperand(&type4); 6999 auto param31 = model->addOperand(&type4); 7000 auto param32 = model->addOperand(&type4); 7001 auto param33 = model->addOperand(&type4); 7002 auto layout = model->addOperand(&type0); 7003 auto param34 = model->addOperand(&type4); 7004 auto param35 = model->addOperand(&type4); 7005 auto op44 = model->addOperand(&type23); 7006 // Phase 2, operations 7007 static uint8_t op24_init[] = {8, 16, 24, 32}; 7008 model->setOperandValue(op24, op24_init, sizeof(uint8_t) * 4); 7009 static int32_t op34_init[] = {0}; 7010 model->setOperandValue(op34, op34_init, sizeof(int32_t) * 1); 7011 static int32_t param30_init[] = {1}; 7012 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7013 static int32_t param31_init[] = {2}; 7014 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7015 static int32_t param32_init[] = {2}; 7016 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7017 static int32_t param33_init[] = {0}; 7018 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7019 static bool8 layout_init[] = {false}; 7020 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7021 static int32_t param34_init[] = {3}; 7022 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7023 static int32_t param35_init[] = {3}; 7024 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7025 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7026 // Phase 3, inputs and outputs 7027 model->identifyInputsAndOutputs( 7028 {op14}, 7029 {op44}); 7030 assert(model->isValid()); 7031 } 7032 7033 inline bool is_ignored_nhwc_quant8_5(int i) { 7034 static std::set<int> ignore = {}; 7035 return ignore.find(i) != ignore.end(); 7036 } 7037 7038 void CreateModel_nhwc_float16_5(Model *model) { 7039 OperandType type0(Type::BOOL, {}); 7040 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 7041 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 7042 OperandType type12(Type::TENSOR_FLOAT16, {1}); 7043 OperandType type30(Type::TENSOR_FLOAT16, {1, 6, 6, 1}); 7044 OperandType type4(Type::INT32, {}); 7045 // Phase 1, operands 7046 auto op14 = model->addOperand(&type30); 7047 auto op24 = model->addOperand(&type11); 7048 auto op34 = model->addOperand(&type12); 7049 auto param30 = model->addOperand(&type4); 7050 auto param31 = model->addOperand(&type4); 7051 auto param32 = model->addOperand(&type4); 7052 auto param33 = model->addOperand(&type4); 7053 auto layout = model->addOperand(&type0); 7054 auto param34 = model->addOperand(&type4); 7055 auto param35 = model->addOperand(&type4); 7056 auto op44 = model->addOperand(&type10); 7057 // Phase 2, operations 7058 static _Float16 op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7059 model->setOperandValue(op24, op24_init, sizeof(_Float16) * 4); 7060 static _Float16 op34_init[] = {0.0f}; 7061 model->setOperandValue(op34, op34_init, sizeof(_Float16) * 1); 7062 static int32_t param30_init[] = {1}; 7063 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7064 static int32_t param31_init[] = {2}; 7065 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7066 static int32_t param32_init[] = {2}; 7067 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7068 static int32_t param33_init[] = {0}; 7069 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7070 static bool8 layout_init[] = {false}; 7071 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7072 static int32_t param34_init[] = {3}; 7073 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7074 static int32_t param35_init[] = {3}; 7075 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7076 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7077 // Phase 3, inputs and outputs 7078 model->identifyInputsAndOutputs( 7079 {op14}, 7080 {op44}); 7081 assert(model->isValid()); 7082 } 7083 7084 inline bool is_ignored_nhwc_float16_5(int i) { 7085 static std::set<int> ignore = {}; 7086 return ignore.find(i) != ignore.end(); 7087 } 7088 7089 void CreateModel_nhwc_weight_as_input_5(Model *model) { 7090 OperandType type0(Type::BOOL, {}); 7091 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 7092 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7093 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7094 OperandType type4(Type::INT32, {}); 7095 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7096 // Phase 1, operands 7097 auto op14 = model->addOperand(&type6); 7098 auto op24 = model->addOperand(&type2); 7099 auto op34 = model->addOperand(&type3); 7100 auto param30 = model->addOperand(&type4); 7101 auto param31 = model->addOperand(&type4); 7102 auto param32 = model->addOperand(&type4); 7103 auto param33 = model->addOperand(&type4); 7104 auto layout = model->addOperand(&type0); 7105 auto param34 = model->addOperand(&type4); 7106 auto param35 = model->addOperand(&type4); 7107 auto op44 = model->addOperand(&type1); 7108 // Phase 2, operations 7109 static int32_t param30_init[] = {1}; 7110 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7111 static int32_t param31_init[] = {2}; 7112 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7113 static int32_t param32_init[] = {2}; 7114 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7115 static int32_t param33_init[] = {0}; 7116 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7117 static bool8 layout_init[] = {false}; 7118 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7119 static int32_t param34_init[] = {3}; 7120 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7121 static int32_t param35_init[] = {3}; 7122 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7123 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7124 // Phase 3, inputs and outputs 7125 model->identifyInputsAndOutputs( 7126 {op14, op24, op34}, 7127 {op44}); 7128 assert(model->isValid()); 7129 } 7130 7131 inline bool is_ignored_nhwc_weight_as_input_5(int i) { 7132 static std::set<int> ignore = {}; 7133 return ignore.find(i) != ignore.end(); 7134 } 7135 7136 void CreateModel_nhwc_weight_as_input_relaxed_5(Model *model) { 7137 OperandType type0(Type::BOOL, {}); 7138 OperandType type1(Type::TENSOR_FLOAT32, {1, 3, 3, 1}); 7139 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7140 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7141 OperandType type4(Type::INT32, {}); 7142 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7143 // Phase 1, operands 7144 auto op14 = model->addOperand(&type6); 7145 auto op24 = model->addOperand(&type2); 7146 auto op34 = model->addOperand(&type3); 7147 auto param30 = model->addOperand(&type4); 7148 auto param31 = model->addOperand(&type4); 7149 auto param32 = model->addOperand(&type4); 7150 auto param33 = model->addOperand(&type4); 7151 auto layout = model->addOperand(&type0); 7152 auto param34 = model->addOperand(&type4); 7153 auto param35 = model->addOperand(&type4); 7154 auto op44 = model->addOperand(&type1); 7155 // Phase 2, operations 7156 static int32_t param30_init[] = {1}; 7157 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7158 static int32_t param31_init[] = {2}; 7159 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7160 static int32_t param32_init[] = {2}; 7161 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7162 static int32_t param33_init[] = {0}; 7163 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7164 static bool8 layout_init[] = {false}; 7165 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7166 static int32_t param34_init[] = {3}; 7167 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7168 static int32_t param35_init[] = {3}; 7169 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7170 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7171 // Phase 3, inputs and outputs 7172 model->identifyInputsAndOutputs( 7173 {op14, op24, op34}, 7174 {op44}); 7175 // Phase 4: set relaxed execution 7176 model->relaxComputationFloat32toFloat16(true); 7177 assert(model->isValid()); 7178 } 7179 7180 inline bool is_ignored_nhwc_weight_as_input_relaxed_5(int i) { 7181 static std::set<int> ignore = {}; 7182 return ignore.find(i) != ignore.end(); 7183 } 7184 7185 void CreateModel_nhwc_weight_as_input_quant8_5(Model *model) { 7186 OperandType type0(Type::BOOL, {}); 7187 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 0.125f, 0); 7188 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {1, 6, 6, 1}, 0.5f, 0); 7189 OperandType type4(Type::INT32, {}); 7190 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 7191 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 7192 // Phase 1, operands 7193 auto op14 = model->addOperand(&type29); 7194 auto op24 = model->addOperand(&type8); 7195 auto op34 = model->addOperand(&type9); 7196 auto param30 = model->addOperand(&type4); 7197 auto param31 = model->addOperand(&type4); 7198 auto param32 = model->addOperand(&type4); 7199 auto param33 = model->addOperand(&type4); 7200 auto layout = model->addOperand(&type0); 7201 auto param34 = model->addOperand(&type4); 7202 auto param35 = model->addOperand(&type4); 7203 auto op44 = model->addOperand(&type23); 7204 // Phase 2, operations 7205 static int32_t param30_init[] = {1}; 7206 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7207 static int32_t param31_init[] = {2}; 7208 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7209 static int32_t param32_init[] = {2}; 7210 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7211 static int32_t param33_init[] = {0}; 7212 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7213 static bool8 layout_init[] = {false}; 7214 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7215 static int32_t param34_init[] = {3}; 7216 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7217 static int32_t param35_init[] = {3}; 7218 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7219 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7220 // Phase 3, inputs and outputs 7221 model->identifyInputsAndOutputs( 7222 {op14, op24, op34}, 7223 {op44}); 7224 assert(model->isValid()); 7225 } 7226 7227 inline bool is_ignored_nhwc_weight_as_input_quant8_5(int i) { 7228 static std::set<int> ignore = {}; 7229 return ignore.find(i) != ignore.end(); 7230 } 7231 7232 void CreateModel_nhwc_weight_as_input_float16_5(Model *model) { 7233 OperandType type0(Type::BOOL, {}); 7234 OperandType type10(Type::TENSOR_FLOAT16, {1, 3, 3, 1}); 7235 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 7236 OperandType type12(Type::TENSOR_FLOAT16, {1}); 7237 OperandType type30(Type::TENSOR_FLOAT16, {1, 6, 6, 1}); 7238 OperandType type4(Type::INT32, {}); 7239 // Phase 1, operands 7240 auto op14 = model->addOperand(&type30); 7241 auto op24 = model->addOperand(&type11); 7242 auto op34 = model->addOperand(&type12); 7243 auto param30 = model->addOperand(&type4); 7244 auto param31 = model->addOperand(&type4); 7245 auto param32 = model->addOperand(&type4); 7246 auto param33 = model->addOperand(&type4); 7247 auto layout = model->addOperand(&type0); 7248 auto param34 = model->addOperand(&type4); 7249 auto param35 = model->addOperand(&type4); 7250 auto op44 = model->addOperand(&type10); 7251 // Phase 2, operations 7252 static int32_t param30_init[] = {1}; 7253 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7254 static int32_t param31_init[] = {2}; 7255 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7256 static int32_t param32_init[] = {2}; 7257 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7258 static int32_t param33_init[] = {0}; 7259 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7260 static bool8 layout_init[] = {false}; 7261 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7262 static int32_t param34_init[] = {3}; 7263 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7264 static int32_t param35_init[] = {3}; 7265 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7266 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7267 // Phase 3, inputs and outputs 7268 model->identifyInputsAndOutputs( 7269 {op14, op24, op34}, 7270 {op44}); 7271 assert(model->isValid()); 7272 } 7273 7274 inline bool is_ignored_nhwc_weight_as_input_float16_5(int i) { 7275 static std::set<int> ignore = {}; 7276 return ignore.find(i) != ignore.end(); 7277 } 7278 7279 void CreateModel_nchw_5(Model *model) { 7280 OperandType type0(Type::BOOL, {}); 7281 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 7282 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7283 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7284 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 7285 OperandType type4(Type::INT32, {}); 7286 // Phase 1, operands 7287 auto op14 = model->addOperand(&type31); 7288 auto op24 = model->addOperand(&type2); 7289 auto op34 = model->addOperand(&type3); 7290 auto param30 = model->addOperand(&type4); 7291 auto param31 = model->addOperand(&type4); 7292 auto param32 = model->addOperand(&type4); 7293 auto param33 = model->addOperand(&type4); 7294 auto layout = model->addOperand(&type0); 7295 auto param34 = model->addOperand(&type4); 7296 auto param35 = model->addOperand(&type4); 7297 auto op44 = model->addOperand(&type13); 7298 // Phase 2, operations 7299 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7300 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 7301 static float op34_init[] = {0.0f}; 7302 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 7303 static int32_t param30_init[] = {1}; 7304 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7305 static int32_t param31_init[] = {2}; 7306 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7307 static int32_t param32_init[] = {2}; 7308 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7309 static int32_t param33_init[] = {0}; 7310 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7311 static bool8 layout_init[] = {true}; 7312 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7313 static int32_t param34_init[] = {3}; 7314 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7315 static int32_t param35_init[] = {3}; 7316 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7317 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7318 // Phase 3, inputs and outputs 7319 model->identifyInputsAndOutputs( 7320 {op14}, 7321 {op44}); 7322 assert(model->isValid()); 7323 } 7324 7325 inline bool is_ignored_nchw_5(int i) { 7326 static std::set<int> ignore = {}; 7327 return ignore.find(i) != ignore.end(); 7328 } 7329 7330 void CreateModel_nchw_relaxed_5(Model *model) { 7331 OperandType type0(Type::BOOL, {}); 7332 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 7333 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7334 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7335 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 7336 OperandType type4(Type::INT32, {}); 7337 // Phase 1, operands 7338 auto op14 = model->addOperand(&type31); 7339 auto op24 = model->addOperand(&type2); 7340 auto op34 = model->addOperand(&type3); 7341 auto param30 = model->addOperand(&type4); 7342 auto param31 = model->addOperand(&type4); 7343 auto param32 = model->addOperand(&type4); 7344 auto param33 = model->addOperand(&type4); 7345 auto layout = model->addOperand(&type0); 7346 auto param34 = model->addOperand(&type4); 7347 auto param35 = model->addOperand(&type4); 7348 auto op44 = model->addOperand(&type13); 7349 // Phase 2, operations 7350 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7351 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 7352 static float op34_init[] = {0.0f}; 7353 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 7354 static int32_t param30_init[] = {1}; 7355 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7356 static int32_t param31_init[] = {2}; 7357 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7358 static int32_t param32_init[] = {2}; 7359 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7360 static int32_t param33_init[] = {0}; 7361 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7362 static bool8 layout_init[] = {true}; 7363 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7364 static int32_t param34_init[] = {3}; 7365 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7366 static int32_t param35_init[] = {3}; 7367 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7368 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7369 // Phase 3, inputs and outputs 7370 model->identifyInputsAndOutputs( 7371 {op14}, 7372 {op44}); 7373 // Phase 4: set relaxed execution 7374 model->relaxComputationFloat32toFloat16(true); 7375 assert(model->isValid()); 7376 } 7377 7378 inline bool is_ignored_nchw_relaxed_5(int i) { 7379 static std::set<int> ignore = {}; 7380 return ignore.find(i) != ignore.end(); 7381 } 7382 7383 void CreateModel_nchw_quant8_5(Model *model) { 7384 OperandType type0(Type::BOOL, {}); 7385 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 7386 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 1, 6, 6}, 0.5f, 0); 7387 OperandType type4(Type::INT32, {}); 7388 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 7389 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 7390 // Phase 1, operands 7391 auto op14 = model->addOperand(&type32); 7392 auto op24 = model->addOperand(&type8); 7393 auto op34 = model->addOperand(&type9); 7394 auto param30 = model->addOperand(&type4); 7395 auto param31 = model->addOperand(&type4); 7396 auto param32 = model->addOperand(&type4); 7397 auto param33 = model->addOperand(&type4); 7398 auto layout = model->addOperand(&type0); 7399 auto param34 = model->addOperand(&type4); 7400 auto param35 = model->addOperand(&type4); 7401 auto op44 = model->addOperand(&type27); 7402 // Phase 2, operations 7403 static uint8_t op24_init[] = {8, 16, 24, 32}; 7404 model->setOperandValue(op24, op24_init, sizeof(uint8_t) * 4); 7405 static int32_t op34_init[] = {0}; 7406 model->setOperandValue(op34, op34_init, sizeof(int32_t) * 1); 7407 static int32_t param30_init[] = {1}; 7408 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7409 static int32_t param31_init[] = {2}; 7410 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7411 static int32_t param32_init[] = {2}; 7412 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7413 static int32_t param33_init[] = {0}; 7414 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7415 static bool8 layout_init[] = {true}; 7416 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7417 static int32_t param34_init[] = {3}; 7418 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7419 static int32_t param35_init[] = {3}; 7420 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7421 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7422 // Phase 3, inputs and outputs 7423 model->identifyInputsAndOutputs( 7424 {op14}, 7425 {op44}); 7426 assert(model->isValid()); 7427 } 7428 7429 inline bool is_ignored_nchw_quant8_5(int i) { 7430 static std::set<int> ignore = {}; 7431 return ignore.find(i) != ignore.end(); 7432 } 7433 7434 void CreateModel_nchw_float16_5(Model *model) { 7435 OperandType type0(Type::BOOL, {}); 7436 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 7437 OperandType type12(Type::TENSOR_FLOAT16, {1}); 7438 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 7439 OperandType type33(Type::TENSOR_FLOAT16, {1, 1, 6, 6}); 7440 OperandType type4(Type::INT32, {}); 7441 // Phase 1, operands 7442 auto op14 = model->addOperand(&type33); 7443 auto op24 = model->addOperand(&type11); 7444 auto op34 = model->addOperand(&type12); 7445 auto param30 = model->addOperand(&type4); 7446 auto param31 = model->addOperand(&type4); 7447 auto param32 = model->addOperand(&type4); 7448 auto param33 = model->addOperand(&type4); 7449 auto layout = model->addOperand(&type0); 7450 auto param34 = model->addOperand(&type4); 7451 auto param35 = model->addOperand(&type4); 7452 auto op44 = model->addOperand(&type17); 7453 // Phase 2, operations 7454 static _Float16 op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7455 model->setOperandValue(op24, op24_init, sizeof(_Float16) * 4); 7456 static _Float16 op34_init[] = {0.0f}; 7457 model->setOperandValue(op34, op34_init, sizeof(_Float16) * 1); 7458 static int32_t param30_init[] = {1}; 7459 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7460 static int32_t param31_init[] = {2}; 7461 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7462 static int32_t param32_init[] = {2}; 7463 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7464 static int32_t param33_init[] = {0}; 7465 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7466 static bool8 layout_init[] = {true}; 7467 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7468 static int32_t param34_init[] = {3}; 7469 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7470 static int32_t param35_init[] = {3}; 7471 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7472 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7473 // Phase 3, inputs and outputs 7474 model->identifyInputsAndOutputs( 7475 {op14}, 7476 {op44}); 7477 assert(model->isValid()); 7478 } 7479 7480 inline bool is_ignored_nchw_float16_5(int i) { 7481 static std::set<int> ignore = {}; 7482 return ignore.find(i) != ignore.end(); 7483 } 7484 7485 void CreateModel_nchw_weight_as_input_5(Model *model) { 7486 OperandType type0(Type::BOOL, {}); 7487 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 7488 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7489 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7490 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 7491 OperandType type4(Type::INT32, {}); 7492 // Phase 1, operands 7493 auto op14 = model->addOperand(&type31); 7494 auto op24 = model->addOperand(&type2); 7495 auto op34 = model->addOperand(&type3); 7496 auto param30 = model->addOperand(&type4); 7497 auto param31 = model->addOperand(&type4); 7498 auto param32 = model->addOperand(&type4); 7499 auto param33 = model->addOperand(&type4); 7500 auto layout = model->addOperand(&type0); 7501 auto param34 = model->addOperand(&type4); 7502 auto param35 = model->addOperand(&type4); 7503 auto op44 = model->addOperand(&type13); 7504 // Phase 2, operations 7505 static int32_t param30_init[] = {1}; 7506 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7507 static int32_t param31_init[] = {2}; 7508 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7509 static int32_t param32_init[] = {2}; 7510 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7511 static int32_t param33_init[] = {0}; 7512 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7513 static bool8 layout_init[] = {true}; 7514 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7515 static int32_t param34_init[] = {3}; 7516 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7517 static int32_t param35_init[] = {3}; 7518 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7519 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7520 // Phase 3, inputs and outputs 7521 model->identifyInputsAndOutputs( 7522 {op14, op24, op34}, 7523 {op44}); 7524 assert(model->isValid()); 7525 } 7526 7527 inline bool is_ignored_nchw_weight_as_input_5(int i) { 7528 static std::set<int> ignore = {}; 7529 return ignore.find(i) != ignore.end(); 7530 } 7531 7532 void CreateModel_nchw_weight_as_input_relaxed_5(Model *model) { 7533 OperandType type0(Type::BOOL, {}); 7534 OperandType type13(Type::TENSOR_FLOAT32, {1, 1, 3, 3}); 7535 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7536 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7537 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 7538 OperandType type4(Type::INT32, {}); 7539 // Phase 1, operands 7540 auto op14 = model->addOperand(&type31); 7541 auto op24 = model->addOperand(&type2); 7542 auto op34 = model->addOperand(&type3); 7543 auto param30 = model->addOperand(&type4); 7544 auto param31 = model->addOperand(&type4); 7545 auto param32 = model->addOperand(&type4); 7546 auto param33 = model->addOperand(&type4); 7547 auto layout = model->addOperand(&type0); 7548 auto param34 = model->addOperand(&type4); 7549 auto param35 = model->addOperand(&type4); 7550 auto op44 = model->addOperand(&type13); 7551 // Phase 2, operations 7552 static int32_t param30_init[] = {1}; 7553 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7554 static int32_t param31_init[] = {2}; 7555 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7556 static int32_t param32_init[] = {2}; 7557 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7558 static int32_t param33_init[] = {0}; 7559 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7560 static bool8 layout_init[] = {true}; 7561 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7562 static int32_t param34_init[] = {3}; 7563 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7564 static int32_t param35_init[] = {3}; 7565 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7566 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7567 // Phase 3, inputs and outputs 7568 model->identifyInputsAndOutputs( 7569 {op14, op24, op34}, 7570 {op44}); 7571 // Phase 4: set relaxed execution 7572 model->relaxComputationFloat32toFloat16(true); 7573 assert(model->isValid()); 7574 } 7575 7576 inline bool is_ignored_nchw_weight_as_input_relaxed_5(int i) { 7577 static std::set<int> ignore = {}; 7578 return ignore.find(i) != ignore.end(); 7579 } 7580 7581 void CreateModel_nchw_weight_as_input_quant8_5(Model *model) { 7582 OperandType type0(Type::BOOL, {}); 7583 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 1, 3, 3}, 0.125f, 0); 7584 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 1, 6, 6}, 0.5f, 0); 7585 OperandType type4(Type::INT32, {}); 7586 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 7587 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 7588 // Phase 1, operands 7589 auto op14 = model->addOperand(&type32); 7590 auto op24 = model->addOperand(&type8); 7591 auto op34 = model->addOperand(&type9); 7592 auto param30 = model->addOperand(&type4); 7593 auto param31 = model->addOperand(&type4); 7594 auto param32 = model->addOperand(&type4); 7595 auto param33 = model->addOperand(&type4); 7596 auto layout = model->addOperand(&type0); 7597 auto param34 = model->addOperand(&type4); 7598 auto param35 = model->addOperand(&type4); 7599 auto op44 = model->addOperand(&type27); 7600 // Phase 2, operations 7601 static int32_t param30_init[] = {1}; 7602 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7603 static int32_t param31_init[] = {2}; 7604 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7605 static int32_t param32_init[] = {2}; 7606 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7607 static int32_t param33_init[] = {0}; 7608 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7609 static bool8 layout_init[] = {true}; 7610 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7611 static int32_t param34_init[] = {3}; 7612 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7613 static int32_t param35_init[] = {3}; 7614 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7615 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7616 // Phase 3, inputs and outputs 7617 model->identifyInputsAndOutputs( 7618 {op14, op24, op34}, 7619 {op44}); 7620 assert(model->isValid()); 7621 } 7622 7623 inline bool is_ignored_nchw_weight_as_input_quant8_5(int i) { 7624 static std::set<int> ignore = {}; 7625 return ignore.find(i) != ignore.end(); 7626 } 7627 7628 void CreateModel_nchw_weight_as_input_float16_5(Model *model) { 7629 OperandType type0(Type::BOOL, {}); 7630 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 7631 OperandType type12(Type::TENSOR_FLOAT16, {1}); 7632 OperandType type17(Type::TENSOR_FLOAT16, {1, 1, 3, 3}); 7633 OperandType type33(Type::TENSOR_FLOAT16, {1, 1, 6, 6}); 7634 OperandType type4(Type::INT32, {}); 7635 // Phase 1, operands 7636 auto op14 = model->addOperand(&type33); 7637 auto op24 = model->addOperand(&type11); 7638 auto op34 = model->addOperand(&type12); 7639 auto param30 = model->addOperand(&type4); 7640 auto param31 = model->addOperand(&type4); 7641 auto param32 = model->addOperand(&type4); 7642 auto param33 = model->addOperand(&type4); 7643 auto layout = model->addOperand(&type0); 7644 auto param34 = model->addOperand(&type4); 7645 auto param35 = model->addOperand(&type4); 7646 auto op44 = model->addOperand(&type17); 7647 // Phase 2, operations 7648 static int32_t param30_init[] = {1}; 7649 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7650 static int32_t param31_init[] = {2}; 7651 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7652 static int32_t param32_init[] = {2}; 7653 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7654 static int32_t param33_init[] = {0}; 7655 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7656 static bool8 layout_init[] = {true}; 7657 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7658 static int32_t param34_init[] = {3}; 7659 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7660 static int32_t param35_init[] = {3}; 7661 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7662 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7663 // Phase 3, inputs and outputs 7664 model->identifyInputsAndOutputs( 7665 {op14, op24, op34}, 7666 {op44}); 7667 assert(model->isValid()); 7668 } 7669 7670 inline bool is_ignored_nchw_weight_as_input_float16_5(int i) { 7671 static std::set<int> ignore = {}; 7672 return ignore.find(i) != ignore.end(); 7673 } 7674 7675 void CreateModel_dynamic_output_shape_nhwc_5(Model *model) { 7676 OperandType type0(Type::BOOL, {}); 7677 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 7678 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7679 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7680 OperandType type4(Type::INT32, {}); 7681 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7682 // Phase 1, operands 7683 auto op14 = model->addOperand(&type6); 7684 auto op24 = model->addOperand(&type2); 7685 auto op34 = model->addOperand(&type3); 7686 auto param30 = model->addOperand(&type4); 7687 auto param31 = model->addOperand(&type4); 7688 auto param32 = model->addOperand(&type4); 7689 auto param33 = model->addOperand(&type4); 7690 auto layout = model->addOperand(&type0); 7691 auto param34 = model->addOperand(&type4); 7692 auto param35 = model->addOperand(&type4); 7693 auto op44 = model->addOperand(&type19); 7694 // Phase 2, operations 7695 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7696 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 7697 static float op34_init[] = {0.0f}; 7698 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 7699 static int32_t param30_init[] = {1}; 7700 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7701 static int32_t param31_init[] = {2}; 7702 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7703 static int32_t param32_init[] = {2}; 7704 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7705 static int32_t param33_init[] = {0}; 7706 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7707 static bool8 layout_init[] = {false}; 7708 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7709 static int32_t param34_init[] = {3}; 7710 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7711 static int32_t param35_init[] = {3}; 7712 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7713 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7714 // Phase 3, inputs and outputs 7715 model->identifyInputsAndOutputs( 7716 {op14}, 7717 {op44}); 7718 assert(model->isValid()); 7719 } 7720 7721 inline bool is_ignored_dynamic_output_shape_nhwc_5(int i) { 7722 static std::set<int> ignore = {}; 7723 return ignore.find(i) != ignore.end(); 7724 } 7725 7726 void CreateModel_dynamic_output_shape_nhwc_relaxed_5(Model *model) { 7727 OperandType type0(Type::BOOL, {}); 7728 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 7729 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7730 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7731 OperandType type4(Type::INT32, {}); 7732 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7733 // Phase 1, operands 7734 auto op14 = model->addOperand(&type6); 7735 auto op24 = model->addOperand(&type2); 7736 auto op34 = model->addOperand(&type3); 7737 auto param30 = model->addOperand(&type4); 7738 auto param31 = model->addOperand(&type4); 7739 auto param32 = model->addOperand(&type4); 7740 auto param33 = model->addOperand(&type4); 7741 auto layout = model->addOperand(&type0); 7742 auto param34 = model->addOperand(&type4); 7743 auto param35 = model->addOperand(&type4); 7744 auto op44 = model->addOperand(&type19); 7745 // Phase 2, operations 7746 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7747 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 7748 static float op34_init[] = {0.0f}; 7749 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 7750 static int32_t param30_init[] = {1}; 7751 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7752 static int32_t param31_init[] = {2}; 7753 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7754 static int32_t param32_init[] = {2}; 7755 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7756 static int32_t param33_init[] = {0}; 7757 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7758 static bool8 layout_init[] = {false}; 7759 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7760 static int32_t param34_init[] = {3}; 7761 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7762 static int32_t param35_init[] = {3}; 7763 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7764 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7765 // Phase 3, inputs and outputs 7766 model->identifyInputsAndOutputs( 7767 {op14}, 7768 {op44}); 7769 // Phase 4: set relaxed execution 7770 model->relaxComputationFloat32toFloat16(true); 7771 assert(model->isValid()); 7772 } 7773 7774 inline bool is_ignored_dynamic_output_shape_nhwc_relaxed_5(int i) { 7775 static std::set<int> ignore = {}; 7776 return ignore.find(i) != ignore.end(); 7777 } 7778 7779 void CreateModel_dynamic_output_shape_nhwc_quant8_5(Model *model) { 7780 OperandType type0(Type::BOOL, {}); 7781 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 7782 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {1, 6, 6, 1}, 0.5f, 0); 7783 OperandType type4(Type::INT32, {}); 7784 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 7785 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 7786 // Phase 1, operands 7787 auto op14 = model->addOperand(&type29); 7788 auto op24 = model->addOperand(&type8); 7789 auto op34 = model->addOperand(&type9); 7790 auto param30 = model->addOperand(&type4); 7791 auto param31 = model->addOperand(&type4); 7792 auto param32 = model->addOperand(&type4); 7793 auto param33 = model->addOperand(&type4); 7794 auto layout = model->addOperand(&type0); 7795 auto param34 = model->addOperand(&type4); 7796 auto param35 = model->addOperand(&type4); 7797 auto op44 = model->addOperand(&type20); 7798 // Phase 2, operations 7799 static uint8_t op24_init[] = {8, 16, 24, 32}; 7800 model->setOperandValue(op24, op24_init, sizeof(uint8_t) * 4); 7801 static int32_t op34_init[] = {0}; 7802 model->setOperandValue(op34, op34_init, sizeof(int32_t) * 1); 7803 static int32_t param30_init[] = {1}; 7804 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7805 static int32_t param31_init[] = {2}; 7806 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7807 static int32_t param32_init[] = {2}; 7808 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7809 static int32_t param33_init[] = {0}; 7810 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7811 static bool8 layout_init[] = {false}; 7812 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7813 static int32_t param34_init[] = {3}; 7814 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7815 static int32_t param35_init[] = {3}; 7816 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7817 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7818 // Phase 3, inputs and outputs 7819 model->identifyInputsAndOutputs( 7820 {op14}, 7821 {op44}); 7822 assert(model->isValid()); 7823 } 7824 7825 inline bool is_ignored_dynamic_output_shape_nhwc_quant8_5(int i) { 7826 static std::set<int> ignore = {}; 7827 return ignore.find(i) != ignore.end(); 7828 } 7829 7830 void CreateModel_dynamic_output_shape_nhwc_float16_5(Model *model) { 7831 OperandType type0(Type::BOOL, {}); 7832 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 7833 OperandType type12(Type::TENSOR_FLOAT16, {1}); 7834 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 7835 OperandType type30(Type::TENSOR_FLOAT16, {1, 6, 6, 1}); 7836 OperandType type4(Type::INT32, {}); 7837 // Phase 1, operands 7838 auto op14 = model->addOperand(&type30); 7839 auto op24 = model->addOperand(&type11); 7840 auto op34 = model->addOperand(&type12); 7841 auto param30 = model->addOperand(&type4); 7842 auto param31 = model->addOperand(&type4); 7843 auto param32 = model->addOperand(&type4); 7844 auto param33 = model->addOperand(&type4); 7845 auto layout = model->addOperand(&type0); 7846 auto param34 = model->addOperand(&type4); 7847 auto param35 = model->addOperand(&type4); 7848 auto op44 = model->addOperand(&type21); 7849 // Phase 2, operations 7850 static _Float16 op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 7851 model->setOperandValue(op24, op24_init, sizeof(_Float16) * 4); 7852 static _Float16 op34_init[] = {0.0f}; 7853 model->setOperandValue(op34, op34_init, sizeof(_Float16) * 1); 7854 static int32_t param30_init[] = {1}; 7855 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7856 static int32_t param31_init[] = {2}; 7857 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7858 static int32_t param32_init[] = {2}; 7859 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7860 static int32_t param33_init[] = {0}; 7861 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7862 static bool8 layout_init[] = {false}; 7863 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7864 static int32_t param34_init[] = {3}; 7865 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7866 static int32_t param35_init[] = {3}; 7867 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7868 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7869 // Phase 3, inputs and outputs 7870 model->identifyInputsAndOutputs( 7871 {op14}, 7872 {op44}); 7873 assert(model->isValid()); 7874 } 7875 7876 inline bool is_ignored_dynamic_output_shape_nhwc_float16_5(int i) { 7877 static std::set<int> ignore = {}; 7878 return ignore.find(i) != ignore.end(); 7879 } 7880 7881 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_5(Model *model) { 7882 OperandType type0(Type::BOOL, {}); 7883 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 7884 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7885 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7886 OperandType type4(Type::INT32, {}); 7887 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7888 // Phase 1, operands 7889 auto op14 = model->addOperand(&type6); 7890 auto op24 = model->addOperand(&type2); 7891 auto op34 = model->addOperand(&type3); 7892 auto param30 = model->addOperand(&type4); 7893 auto param31 = model->addOperand(&type4); 7894 auto param32 = model->addOperand(&type4); 7895 auto param33 = model->addOperand(&type4); 7896 auto layout = model->addOperand(&type0); 7897 auto param34 = model->addOperand(&type4); 7898 auto param35 = model->addOperand(&type4); 7899 auto op44 = model->addOperand(&type19); 7900 // Phase 2, operations 7901 static int32_t param30_init[] = {1}; 7902 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7903 static int32_t param31_init[] = {2}; 7904 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7905 static int32_t param32_init[] = {2}; 7906 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7907 static int32_t param33_init[] = {0}; 7908 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7909 static bool8 layout_init[] = {false}; 7910 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7911 static int32_t param34_init[] = {3}; 7912 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7913 static int32_t param35_init[] = {3}; 7914 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7915 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7916 // Phase 3, inputs and outputs 7917 model->identifyInputsAndOutputs( 7918 {op14, op24, op34}, 7919 {op44}); 7920 assert(model->isValid()); 7921 } 7922 7923 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_5(int i) { 7924 static std::set<int> ignore = {}; 7925 return ignore.find(i) != ignore.end(); 7926 } 7927 7928 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_relaxed_5(Model *model) { 7929 OperandType type0(Type::BOOL, {}); 7930 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 7931 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 7932 OperandType type3(Type::TENSOR_FLOAT32, {1}); 7933 OperandType type4(Type::INT32, {}); 7934 OperandType type6(Type::TENSOR_FLOAT32, {1, 6, 6, 1}); 7935 // Phase 1, operands 7936 auto op14 = model->addOperand(&type6); 7937 auto op24 = model->addOperand(&type2); 7938 auto op34 = model->addOperand(&type3); 7939 auto param30 = model->addOperand(&type4); 7940 auto param31 = model->addOperand(&type4); 7941 auto param32 = model->addOperand(&type4); 7942 auto param33 = model->addOperand(&type4); 7943 auto layout = model->addOperand(&type0); 7944 auto param34 = model->addOperand(&type4); 7945 auto param35 = model->addOperand(&type4); 7946 auto op44 = model->addOperand(&type19); 7947 // Phase 2, operations 7948 static int32_t param30_init[] = {1}; 7949 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7950 static int32_t param31_init[] = {2}; 7951 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 7952 static int32_t param32_init[] = {2}; 7953 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 7954 static int32_t param33_init[] = {0}; 7955 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 7956 static bool8 layout_init[] = {false}; 7957 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 7958 static int32_t param34_init[] = {3}; 7959 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 7960 static int32_t param35_init[] = {3}; 7961 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 7962 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 7963 // Phase 3, inputs and outputs 7964 model->identifyInputsAndOutputs( 7965 {op14, op24, op34}, 7966 {op44}); 7967 // Phase 4: set relaxed execution 7968 model->relaxComputationFloat32toFloat16(true); 7969 assert(model->isValid()); 7970 } 7971 7972 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_relaxed_5(int i) { 7973 static std::set<int> ignore = {}; 7974 return ignore.find(i) != ignore.end(); 7975 } 7976 7977 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_quant8_5(Model *model) { 7978 OperandType type0(Type::BOOL, {}); 7979 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 7980 OperandType type29(Type::TENSOR_QUANT8_ASYMM, {1, 6, 6, 1}, 0.5f, 0); 7981 OperandType type4(Type::INT32, {}); 7982 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 7983 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 7984 // Phase 1, operands 7985 auto op14 = model->addOperand(&type29); 7986 auto op24 = model->addOperand(&type8); 7987 auto op34 = model->addOperand(&type9); 7988 auto param30 = model->addOperand(&type4); 7989 auto param31 = model->addOperand(&type4); 7990 auto param32 = model->addOperand(&type4); 7991 auto param33 = model->addOperand(&type4); 7992 auto layout = model->addOperand(&type0); 7993 auto param34 = model->addOperand(&type4); 7994 auto param35 = model->addOperand(&type4); 7995 auto op44 = model->addOperand(&type20); 7996 // Phase 2, operations 7997 static int32_t param30_init[] = {1}; 7998 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 7999 static int32_t param31_init[] = {2}; 8000 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8001 static int32_t param32_init[] = {2}; 8002 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8003 static int32_t param33_init[] = {0}; 8004 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8005 static bool8 layout_init[] = {false}; 8006 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8007 static int32_t param34_init[] = {3}; 8008 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8009 static int32_t param35_init[] = {3}; 8010 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8011 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8012 // Phase 3, inputs and outputs 8013 model->identifyInputsAndOutputs( 8014 {op14, op24, op34}, 8015 {op44}); 8016 assert(model->isValid()); 8017 } 8018 8019 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_quant8_5(int i) { 8020 static std::set<int> ignore = {}; 8021 return ignore.find(i) != ignore.end(); 8022 } 8023 8024 void CreateModel_dynamic_output_shape_nhwc_weight_as_input_float16_5(Model *model) { 8025 OperandType type0(Type::BOOL, {}); 8026 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 8027 OperandType type12(Type::TENSOR_FLOAT16, {1}); 8028 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 8029 OperandType type30(Type::TENSOR_FLOAT16, {1, 6, 6, 1}); 8030 OperandType type4(Type::INT32, {}); 8031 // Phase 1, operands 8032 auto op14 = model->addOperand(&type30); 8033 auto op24 = model->addOperand(&type11); 8034 auto op34 = model->addOperand(&type12); 8035 auto param30 = model->addOperand(&type4); 8036 auto param31 = model->addOperand(&type4); 8037 auto param32 = model->addOperand(&type4); 8038 auto param33 = model->addOperand(&type4); 8039 auto layout = model->addOperand(&type0); 8040 auto param34 = model->addOperand(&type4); 8041 auto param35 = model->addOperand(&type4); 8042 auto op44 = model->addOperand(&type21); 8043 // Phase 2, operations 8044 static int32_t param30_init[] = {1}; 8045 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8046 static int32_t param31_init[] = {2}; 8047 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8048 static int32_t param32_init[] = {2}; 8049 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8050 static int32_t param33_init[] = {0}; 8051 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8052 static bool8 layout_init[] = {false}; 8053 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8054 static int32_t param34_init[] = {3}; 8055 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8056 static int32_t param35_init[] = {3}; 8057 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8058 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8059 // Phase 3, inputs and outputs 8060 model->identifyInputsAndOutputs( 8061 {op14, op24, op34}, 8062 {op44}); 8063 assert(model->isValid()); 8064 } 8065 8066 inline bool is_ignored_dynamic_output_shape_nhwc_weight_as_input_float16_5(int i) { 8067 static std::set<int> ignore = {}; 8068 return ignore.find(i) != ignore.end(); 8069 } 8070 8071 void CreateModel_dynamic_output_shape_nchw_5(Model *model) { 8072 OperandType type0(Type::BOOL, {}); 8073 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 8074 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 8075 OperandType type3(Type::TENSOR_FLOAT32, {1}); 8076 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 8077 OperandType type4(Type::INT32, {}); 8078 // Phase 1, operands 8079 auto op14 = model->addOperand(&type31); 8080 auto op24 = model->addOperand(&type2); 8081 auto op34 = model->addOperand(&type3); 8082 auto param30 = model->addOperand(&type4); 8083 auto param31 = model->addOperand(&type4); 8084 auto param32 = model->addOperand(&type4); 8085 auto param33 = model->addOperand(&type4); 8086 auto layout = model->addOperand(&type0); 8087 auto param34 = model->addOperand(&type4); 8088 auto param35 = model->addOperand(&type4); 8089 auto op44 = model->addOperand(&type19); 8090 // Phase 2, operations 8091 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 8092 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 8093 static float op34_init[] = {0.0f}; 8094 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 8095 static int32_t param30_init[] = {1}; 8096 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8097 static int32_t param31_init[] = {2}; 8098 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8099 static int32_t param32_init[] = {2}; 8100 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8101 static int32_t param33_init[] = {0}; 8102 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8103 static bool8 layout_init[] = {true}; 8104 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8105 static int32_t param34_init[] = {3}; 8106 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8107 static int32_t param35_init[] = {3}; 8108 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8109 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8110 // Phase 3, inputs and outputs 8111 model->identifyInputsAndOutputs( 8112 {op14}, 8113 {op44}); 8114 assert(model->isValid()); 8115 } 8116 8117 inline bool is_ignored_dynamic_output_shape_nchw_5(int i) { 8118 static std::set<int> ignore = {}; 8119 return ignore.find(i) != ignore.end(); 8120 } 8121 8122 void CreateModel_dynamic_output_shape_nchw_relaxed_5(Model *model) { 8123 OperandType type0(Type::BOOL, {}); 8124 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 8125 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 8126 OperandType type3(Type::TENSOR_FLOAT32, {1}); 8127 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 8128 OperandType type4(Type::INT32, {}); 8129 // Phase 1, operands 8130 auto op14 = model->addOperand(&type31); 8131 auto op24 = model->addOperand(&type2); 8132 auto op34 = model->addOperand(&type3); 8133 auto param30 = model->addOperand(&type4); 8134 auto param31 = model->addOperand(&type4); 8135 auto param32 = model->addOperand(&type4); 8136 auto param33 = model->addOperand(&type4); 8137 auto layout = model->addOperand(&type0); 8138 auto param34 = model->addOperand(&type4); 8139 auto param35 = model->addOperand(&type4); 8140 auto op44 = model->addOperand(&type19); 8141 // Phase 2, operations 8142 static float op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 8143 model->setOperandValue(op24, op24_init, sizeof(float) * 4); 8144 static float op34_init[] = {0.0f}; 8145 model->setOperandValue(op34, op34_init, sizeof(float) * 1); 8146 static int32_t param30_init[] = {1}; 8147 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8148 static int32_t param31_init[] = {2}; 8149 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8150 static int32_t param32_init[] = {2}; 8151 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8152 static int32_t param33_init[] = {0}; 8153 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8154 static bool8 layout_init[] = {true}; 8155 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8156 static int32_t param34_init[] = {3}; 8157 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8158 static int32_t param35_init[] = {3}; 8159 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8160 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8161 // Phase 3, inputs and outputs 8162 model->identifyInputsAndOutputs( 8163 {op14}, 8164 {op44}); 8165 // Phase 4: set relaxed execution 8166 model->relaxComputationFloat32toFloat16(true); 8167 assert(model->isValid()); 8168 } 8169 8170 inline bool is_ignored_dynamic_output_shape_nchw_relaxed_5(int i) { 8171 static std::set<int> ignore = {}; 8172 return ignore.find(i) != ignore.end(); 8173 } 8174 8175 void CreateModel_dynamic_output_shape_nchw_quant8_5(Model *model) { 8176 OperandType type0(Type::BOOL, {}); 8177 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 8178 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 1, 6, 6}, 0.5f, 0); 8179 OperandType type4(Type::INT32, {}); 8180 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 8181 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 8182 // Phase 1, operands 8183 auto op14 = model->addOperand(&type32); 8184 auto op24 = model->addOperand(&type8); 8185 auto op34 = model->addOperand(&type9); 8186 auto param30 = model->addOperand(&type4); 8187 auto param31 = model->addOperand(&type4); 8188 auto param32 = model->addOperand(&type4); 8189 auto param33 = model->addOperand(&type4); 8190 auto layout = model->addOperand(&type0); 8191 auto param34 = model->addOperand(&type4); 8192 auto param35 = model->addOperand(&type4); 8193 auto op44 = model->addOperand(&type20); 8194 // Phase 2, operations 8195 static uint8_t op24_init[] = {8, 16, 24, 32}; 8196 model->setOperandValue(op24, op24_init, sizeof(uint8_t) * 4); 8197 static int32_t op34_init[] = {0}; 8198 model->setOperandValue(op34, op34_init, sizeof(int32_t) * 1); 8199 static int32_t param30_init[] = {1}; 8200 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8201 static int32_t param31_init[] = {2}; 8202 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8203 static int32_t param32_init[] = {2}; 8204 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8205 static int32_t param33_init[] = {0}; 8206 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8207 static bool8 layout_init[] = {true}; 8208 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8209 static int32_t param34_init[] = {3}; 8210 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8211 static int32_t param35_init[] = {3}; 8212 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8213 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8214 // Phase 3, inputs and outputs 8215 model->identifyInputsAndOutputs( 8216 {op14}, 8217 {op44}); 8218 assert(model->isValid()); 8219 } 8220 8221 inline bool is_ignored_dynamic_output_shape_nchw_quant8_5(int i) { 8222 static std::set<int> ignore = {}; 8223 return ignore.find(i) != ignore.end(); 8224 } 8225 8226 void CreateModel_dynamic_output_shape_nchw_float16_5(Model *model) { 8227 OperandType type0(Type::BOOL, {}); 8228 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 8229 OperandType type12(Type::TENSOR_FLOAT16, {1}); 8230 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 8231 OperandType type33(Type::TENSOR_FLOAT16, {1, 1, 6, 6}); 8232 OperandType type4(Type::INT32, {}); 8233 // Phase 1, operands 8234 auto op14 = model->addOperand(&type33); 8235 auto op24 = model->addOperand(&type11); 8236 auto op34 = model->addOperand(&type12); 8237 auto param30 = model->addOperand(&type4); 8238 auto param31 = model->addOperand(&type4); 8239 auto param32 = model->addOperand(&type4); 8240 auto param33 = model->addOperand(&type4); 8241 auto layout = model->addOperand(&type0); 8242 auto param34 = model->addOperand(&type4); 8243 auto param35 = model->addOperand(&type4); 8244 auto op44 = model->addOperand(&type21); 8245 // Phase 2, operations 8246 static _Float16 op24_init[] = {1.0f, 2.0f, 3.0f, 4.0f}; 8247 model->setOperandValue(op24, op24_init, sizeof(_Float16) * 4); 8248 static _Float16 op34_init[] = {0.0f}; 8249 model->setOperandValue(op34, op34_init, sizeof(_Float16) * 1); 8250 static int32_t param30_init[] = {1}; 8251 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8252 static int32_t param31_init[] = {2}; 8253 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8254 static int32_t param32_init[] = {2}; 8255 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8256 static int32_t param33_init[] = {0}; 8257 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8258 static bool8 layout_init[] = {true}; 8259 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8260 static int32_t param34_init[] = {3}; 8261 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8262 static int32_t param35_init[] = {3}; 8263 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8264 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8265 // Phase 3, inputs and outputs 8266 model->identifyInputsAndOutputs( 8267 {op14}, 8268 {op44}); 8269 assert(model->isValid()); 8270 } 8271 8272 inline bool is_ignored_dynamic_output_shape_nchw_float16_5(int i) { 8273 static std::set<int> ignore = {}; 8274 return ignore.find(i) != ignore.end(); 8275 } 8276 8277 void CreateModel_dynamic_output_shape_nchw_weight_as_input_5(Model *model) { 8278 OperandType type0(Type::BOOL, {}); 8279 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 8280 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 8281 OperandType type3(Type::TENSOR_FLOAT32, {1}); 8282 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 8283 OperandType type4(Type::INT32, {}); 8284 // Phase 1, operands 8285 auto op14 = model->addOperand(&type31); 8286 auto op24 = model->addOperand(&type2); 8287 auto op34 = model->addOperand(&type3); 8288 auto param30 = model->addOperand(&type4); 8289 auto param31 = model->addOperand(&type4); 8290 auto param32 = model->addOperand(&type4); 8291 auto param33 = model->addOperand(&type4); 8292 auto layout = model->addOperand(&type0); 8293 auto param34 = model->addOperand(&type4); 8294 auto param35 = model->addOperand(&type4); 8295 auto op44 = model->addOperand(&type19); 8296 // Phase 2, operations 8297 static int32_t param30_init[] = {1}; 8298 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8299 static int32_t param31_init[] = {2}; 8300 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8301 static int32_t param32_init[] = {2}; 8302 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8303 static int32_t param33_init[] = {0}; 8304 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8305 static bool8 layout_init[] = {true}; 8306 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8307 static int32_t param34_init[] = {3}; 8308 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8309 static int32_t param35_init[] = {3}; 8310 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8311 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8312 // Phase 3, inputs and outputs 8313 model->identifyInputsAndOutputs( 8314 {op14, op24, op34}, 8315 {op44}); 8316 assert(model->isValid()); 8317 } 8318 8319 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_5(int i) { 8320 static std::set<int> ignore = {}; 8321 return ignore.find(i) != ignore.end(); 8322 } 8323 8324 void CreateModel_dynamic_output_shape_nchw_weight_as_input_relaxed_5(Model *model) { 8325 OperandType type0(Type::BOOL, {}); 8326 OperandType type19(Type::TENSOR_FLOAT32, {0, 0, 0, 0}); 8327 OperandType type2(Type::TENSOR_FLOAT32, {1, 2, 2, 1}); 8328 OperandType type3(Type::TENSOR_FLOAT32, {1}); 8329 OperandType type31(Type::TENSOR_FLOAT32, {1, 1, 6, 6}); 8330 OperandType type4(Type::INT32, {}); 8331 // Phase 1, operands 8332 auto op14 = model->addOperand(&type31); 8333 auto op24 = model->addOperand(&type2); 8334 auto op34 = model->addOperand(&type3); 8335 auto param30 = model->addOperand(&type4); 8336 auto param31 = model->addOperand(&type4); 8337 auto param32 = model->addOperand(&type4); 8338 auto param33 = model->addOperand(&type4); 8339 auto layout = model->addOperand(&type0); 8340 auto param34 = model->addOperand(&type4); 8341 auto param35 = model->addOperand(&type4); 8342 auto op44 = model->addOperand(&type19); 8343 // Phase 2, operations 8344 static int32_t param30_init[] = {1}; 8345 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8346 static int32_t param31_init[] = {2}; 8347 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8348 static int32_t param32_init[] = {2}; 8349 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8350 static int32_t param33_init[] = {0}; 8351 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8352 static bool8 layout_init[] = {true}; 8353 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8354 static int32_t param34_init[] = {3}; 8355 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8356 static int32_t param35_init[] = {3}; 8357 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8358 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8359 // Phase 3, inputs and outputs 8360 model->identifyInputsAndOutputs( 8361 {op14, op24, op34}, 8362 {op44}); 8363 // Phase 4: set relaxed execution 8364 model->relaxComputationFloat32toFloat16(true); 8365 assert(model->isValid()); 8366 } 8367 8368 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_relaxed_5(int i) { 8369 static std::set<int> ignore = {}; 8370 return ignore.find(i) != ignore.end(); 8371 } 8372 8373 void CreateModel_dynamic_output_shape_nchw_weight_as_input_quant8_5(Model *model) { 8374 OperandType type0(Type::BOOL, {}); 8375 OperandType type20(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.125f, 0); 8376 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {1, 1, 6, 6}, 0.5f, 0); 8377 OperandType type4(Type::INT32, {}); 8378 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1, 2, 2, 1}, 0.125f, 0); 8379 OperandType type9(Type::TENSOR_INT32, {1}, 0.0625f, 0); 8380 // Phase 1, operands 8381 auto op14 = model->addOperand(&type32); 8382 auto op24 = model->addOperand(&type8); 8383 auto op34 = model->addOperand(&type9); 8384 auto param30 = model->addOperand(&type4); 8385 auto param31 = model->addOperand(&type4); 8386 auto param32 = model->addOperand(&type4); 8387 auto param33 = model->addOperand(&type4); 8388 auto layout = model->addOperand(&type0); 8389 auto param34 = model->addOperand(&type4); 8390 auto param35 = model->addOperand(&type4); 8391 auto op44 = model->addOperand(&type20); 8392 // Phase 2, operations 8393 static int32_t param30_init[] = {1}; 8394 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8395 static int32_t param31_init[] = {2}; 8396 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8397 static int32_t param32_init[] = {2}; 8398 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8399 static int32_t param33_init[] = {0}; 8400 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8401 static bool8 layout_init[] = {true}; 8402 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8403 static int32_t param34_init[] = {3}; 8404 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8405 static int32_t param35_init[] = {3}; 8406 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8407 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8408 // Phase 3, inputs and outputs 8409 model->identifyInputsAndOutputs( 8410 {op14, op24, op34}, 8411 {op44}); 8412 assert(model->isValid()); 8413 } 8414 8415 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_quant8_5(int i) { 8416 static std::set<int> ignore = {}; 8417 return ignore.find(i) != ignore.end(); 8418 } 8419 8420 void CreateModel_dynamic_output_shape_nchw_weight_as_input_float16_5(Model *model) { 8421 OperandType type0(Type::BOOL, {}); 8422 OperandType type11(Type::TENSOR_FLOAT16, {1, 2, 2, 1}); 8423 OperandType type12(Type::TENSOR_FLOAT16, {1}); 8424 OperandType type21(Type::TENSOR_FLOAT16, {0, 0, 0, 0}); 8425 OperandType type33(Type::TENSOR_FLOAT16, {1, 1, 6, 6}); 8426 OperandType type4(Type::INT32, {}); 8427 // Phase 1, operands 8428 auto op14 = model->addOperand(&type33); 8429 auto op24 = model->addOperand(&type11); 8430 auto op34 = model->addOperand(&type12); 8431 auto param30 = model->addOperand(&type4); 8432 auto param31 = model->addOperand(&type4); 8433 auto param32 = model->addOperand(&type4); 8434 auto param33 = model->addOperand(&type4); 8435 auto layout = model->addOperand(&type0); 8436 auto param34 = model->addOperand(&type4); 8437 auto param35 = model->addOperand(&type4); 8438 auto op44 = model->addOperand(&type21); 8439 // Phase 2, operations 8440 static int32_t param30_init[] = {1}; 8441 model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1); 8442 static int32_t param31_init[] = {2}; 8443 model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1); 8444 static int32_t param32_init[] = {2}; 8445 model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1); 8446 static int32_t param33_init[] = {0}; 8447 model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1); 8448 static bool8 layout_init[] = {true}; 8449 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1); 8450 static int32_t param34_init[] = {3}; 8451 model->setOperandValue(param34, param34_init, sizeof(int32_t) * 1); 8452 static int32_t param35_init[] = {3}; 8453 model->setOperandValue(param35, param35_init, sizeof(int32_t) * 1); 8454 model->addOperation(ANEURALNETWORKS_CONV_2D, {op14, op24, op34, param30, param31, param32, param33, layout, param34, param35}, {op44}); 8455 // Phase 3, inputs and outputs 8456 model->identifyInputsAndOutputs( 8457 {op14, op24, op34}, 8458 {op44}); 8459 assert(model->isValid()); 8460 } 8461 8462 inline bool is_ignored_dynamic_output_shape_nchw_weight_as_input_float16_5(int i) { 8463 static std::set<int> ignore = {}; 8464 return ignore.find(i) != ignore.end(); 8465 } 8466 8467
