Home | History | Annotate | Download | only in models 
      1 // clang-format off
      2 // Generated file (from: conv2d_per_channel.mod.py). Do not edit
      3 void CreateModel(Model *model) {
      4   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
      5   OperandType type1(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
      6   OperandType type2(Type::TENSOR_INT32, {3});
      7   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 3}, 1.0f, 128);
      8   OperandType type4(Type::INT32, {});
      9   // Phase 1, operands
     10   auto op1 = model->addOperand(&type0);
     11   auto op2 = model->addOperand(&type1);
     12   auto op3 = model->addOperand(&type2);
     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 op4 = model->addOperand(&type3);
     21   // Phase 2, operations
     22   static int8_t op2_init[] = {1, 2, 1, 2, 1, 2};
     23   model->setOperandValue(op2, op2_init, sizeof(int8_t) * 6);
     24   static int32_t op3_init[] = {4, 4, 4};
     25   model->setOperandValue(op3, op3_init, sizeof(int32_t) * 3);
     26   static int32_t param_init[] = {0};
     27   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
     28   static int32_t param1_init[] = {0};
     29   model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
     30   static int32_t param2_init[] = {0};
     31   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
     32   static int32_t param3_init[] = {0};
     33   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
     34   static int32_t param4_init[] = {1};
     35   model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
     36   static int32_t param5_init[] = {1};
     37   model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
     38   static int32_t param6_init[] = {0};
     39   model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
     40   model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6}, {op4});
     41   // Phase 3, inputs and outputs
     42   model->identifyInputsAndOutputs(
     43     {op1},
     44     {op4});
     45   assert(model->isValid());
     46 }
     47 
     48 inline bool is_ignored(int i) {
     49   static std::set<int> ignore = {};
     50   return ignore.find(i) != ignore.end();
     51 }
     52 
     53 void CreateModel_weight_as_input(Model *model) {
     54   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
     55   OperandType type18(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
     56   OperandType type2(Type::TENSOR_INT32, {3});
     57   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 3}, 1.0f, 128);
     58   OperandType type4(Type::INT32, {});
     59   // Phase 1, operands
     60   auto op1 = model->addOperand(&type0);
     61   auto op2 = model->addOperand(&type18);
     62   auto op3 = model->addOperand(&type2);
     63   auto param = model->addOperand(&type4);
     64   auto param1 = model->addOperand(&type4);
     65   auto param2 = model->addOperand(&type4);
     66   auto param3 = model->addOperand(&type4);
     67   auto param4 = model->addOperand(&type4);
     68   auto param5 = model->addOperand(&type4);
     69   auto param6 = model->addOperand(&type4);
     70   auto op4 = model->addOperand(&type3);
     71   // Phase 2, operations
     72   static int32_t param_init[] = {0};
     73   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
     74   static int32_t param1_init[] = {0};
     75   model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
     76   static int32_t param2_init[] = {0};
     77   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
     78   static int32_t param3_init[] = {0};
     79   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
     80   static int32_t param4_init[] = {1};
     81   model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
     82   static int32_t param5_init[] = {1};
     83   model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
     84   static int32_t param6_init[] = {0};
     85   model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
     86   model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6}, {op4});
     87   // Phase 3, inputs and outputs
     88   model->identifyInputsAndOutputs(
     89     {op1, op2, op3},
     90     {op4});
     91   assert(model->isValid());
     92 }
     93 
     94 inline bool is_ignored_weight_as_input(int i) {
     95   static std::set<int> ignore = {};
     96   return ignore.find(i) != ignore.end();
     97 }
     98 
     99 void CreateModel_dynamic_output_shape(Model *model) {
    100   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    101   OperandType type1(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    102   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    103   OperandType type2(Type::TENSOR_INT32, {3});
    104   OperandType type4(Type::INT32, {});
    105   // Phase 1, operands
    106   auto op1 = model->addOperand(&type0);
    107   auto op2 = model->addOperand(&type1);
    108   auto op3 = model->addOperand(&type2);
    109   auto param = model->addOperand(&type4);
    110   auto param1 = model->addOperand(&type4);
    111   auto param2 = model->addOperand(&type4);
    112   auto param3 = model->addOperand(&type4);
    113   auto param4 = model->addOperand(&type4);
    114   auto param5 = model->addOperand(&type4);
    115   auto param6 = model->addOperand(&type4);
    116   auto op4 = model->addOperand(&type19);
    117   // Phase 2, operations
    118   static int8_t op2_init[] = {1, 2, 1, 2, 1, 2};
    119   model->setOperandValue(op2, op2_init, sizeof(int8_t) * 6);
    120   static int32_t op3_init[] = {4, 4, 4};
    121   model->setOperandValue(op3, op3_init, sizeof(int32_t) * 3);
    122   static int32_t param_init[] = {0};
    123   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
    124   static int32_t param1_init[] = {0};
    125   model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
    126   static int32_t param2_init[] = {0};
    127   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
    128   static int32_t param3_init[] = {0};
    129   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
    130   static int32_t param4_init[] = {1};
    131   model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
    132   static int32_t param5_init[] = {1};
    133   model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
    134   static int32_t param6_init[] = {0};
    135   model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
    136   model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6}, {op4});
    137   // Phase 3, inputs and outputs
    138   model->identifyInputsAndOutputs(
    139     {op1},
    140     {op4});
    141   assert(model->isValid());
    142 }
    143 
    144 inline bool is_ignored_dynamic_output_shape(int i) {
    145   static std::set<int> ignore = {};
    146   return ignore.find(i) != ignore.end();
    147 }
    148 
    149 void CreateModel_dynamic_output_shape_weight_as_input(Model *model) {
    150   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    151   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    152   OperandType type2(Type::TENSOR_INT32, {3});
    153   OperandType type20(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    154   OperandType type4(Type::INT32, {});
    155   // Phase 1, operands
    156   auto op1 = model->addOperand(&type0);
    157   auto op2 = model->addOperand(&type20);
    158   auto op3 = model->addOperand(&type2);
    159   auto param = model->addOperand(&type4);
    160   auto param1 = model->addOperand(&type4);
    161   auto param2 = model->addOperand(&type4);
    162   auto param3 = model->addOperand(&type4);
    163   auto param4 = model->addOperand(&type4);
    164   auto param5 = model->addOperand(&type4);
    165   auto param6 = model->addOperand(&type4);
    166   auto op4 = model->addOperand(&type19);
    167   // Phase 2, operations
    168   static int32_t param_init[] = {0};
    169   model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
    170   static int32_t param1_init[] = {0};
    171   model->setOperandValue(param1, param1_init, sizeof(int32_t) * 1);
    172   static int32_t param2_init[] = {0};
    173   model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
    174   static int32_t param3_init[] = {0};
    175   model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
    176   static int32_t param4_init[] = {1};
    177   model->setOperandValue(param4, param4_init, sizeof(int32_t) * 1);
    178   static int32_t param5_init[] = {1};
    179   model->setOperandValue(param5, param5_init, sizeof(int32_t) * 1);
    180   static int32_t param6_init[] = {0};
    181   model->setOperandValue(param6, param6_init, sizeof(int32_t) * 1);
    182   model->addOperation(ANEURALNETWORKS_CONV_2D, {op1, op2, op3, param, param1, param2, param3, param4, param5, param6}, {op4});
    183   // Phase 3, inputs and outputs
    184   model->identifyInputsAndOutputs(
    185     {op1, op2, op3},
    186     {op4});
    187   assert(model->isValid());
    188 }
    189 
    190 inline bool is_ignored_dynamic_output_shape_weight_as_input(int i) {
    191   static std::set<int> ignore = {};
    192   return ignore.find(i) != ignore.end();
    193 }
    194 
    195 void CreateModel_layouts_nhwc(Model *model) {
    196   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    197   OperandType type2(Type::TENSOR_INT32, {3});
    198   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 3}, 1.0f, 128);
    199   OperandType type4(Type::INT32, {});
    200   OperandType type5(Type::BOOL, {});
    201   OperandType type6(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    202   // Phase 1, operands
    203   auto op11 = model->addOperand(&type0);
    204   auto op21 = model->addOperand(&type6);
    205   auto op31 = model->addOperand(&type2);
    206   auto param7 = model->addOperand(&type4);
    207   auto param8 = model->addOperand(&type4);
    208   auto param9 = model->addOperand(&type4);
    209   auto param10 = model->addOperand(&type4);
    210   auto param11 = model->addOperand(&type4);
    211   auto param12 = model->addOperand(&type4);
    212   auto param13 = model->addOperand(&type4);
    213   auto layout = model->addOperand(&type5);
    214   auto op41 = model->addOperand(&type3);
    215   // Phase 2, operations
    216   static int8_t op21_init[] = {1, 2, 1, 2, 1, 2};
    217   model->setOperandValue(op21, op21_init, sizeof(int8_t) * 6);
    218   static int32_t op31_init[] = {4, 4, 4};
    219   model->setOperandValue(op31, op31_init, sizeof(int32_t) * 3);
    220   static int32_t param7_init[] = {0};
    221   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    222   static int32_t param8_init[] = {0};
    223   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    224   static int32_t param9_init[] = {0};
    225   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    226   static int32_t param10_init[] = {0};
    227   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    228   static int32_t param11_init[] = {1};
    229   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    230   static int32_t param12_init[] = {1};
    231   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    232   static int32_t param13_init[] = {0};
    233   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    234   static bool8 layout_init[] = {false};
    235   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    236   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    237   // Phase 3, inputs and outputs
    238   model->identifyInputsAndOutputs(
    239     {op11},
    240     {op41});
    241   assert(model->isValid());
    242 }
    243 
    244 inline bool is_ignored_layouts_nhwc(int i) {
    245   static std::set<int> ignore = {};
    246   return ignore.find(i) != ignore.end();
    247 }
    248 
    249 void CreateModel_layouts_nhwc_weight_as_input(Model *model) {
    250   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    251   OperandType type2(Type::TENSOR_INT32, {3});
    252   OperandType type21(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    253   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 3}, 1.0f, 128);
    254   OperandType type4(Type::INT32, {});
    255   OperandType type5(Type::BOOL, {});
    256   // Phase 1, operands
    257   auto op11 = model->addOperand(&type0);
    258   auto op21 = model->addOperand(&type21);
    259   auto op31 = model->addOperand(&type2);
    260   auto param7 = model->addOperand(&type4);
    261   auto param8 = model->addOperand(&type4);
    262   auto param9 = model->addOperand(&type4);
    263   auto param10 = model->addOperand(&type4);
    264   auto param11 = model->addOperand(&type4);
    265   auto param12 = model->addOperand(&type4);
    266   auto param13 = model->addOperand(&type4);
    267   auto layout = model->addOperand(&type5);
    268   auto op41 = model->addOperand(&type3);
    269   // Phase 2, operations
    270   static int32_t param7_init[] = {0};
    271   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    272   static int32_t param8_init[] = {0};
    273   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    274   static int32_t param9_init[] = {0};
    275   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    276   static int32_t param10_init[] = {0};
    277   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    278   static int32_t param11_init[] = {1};
    279   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    280   static int32_t param12_init[] = {1};
    281   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    282   static int32_t param13_init[] = {0};
    283   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    284   static bool8 layout_init[] = {false};
    285   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    286   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    287   // Phase 3, inputs and outputs
    288   model->identifyInputsAndOutputs(
    289     {op11, op21, op31},
    290     {op41});
    291   assert(model->isValid());
    292 }
    293 
    294 inline bool is_ignored_layouts_nhwc_weight_as_input(int i) {
    295   static std::set<int> ignore = {};
    296   return ignore.find(i) != ignore.end();
    297 }
    298 
    299 void CreateModel_layouts_nchw(Model *model) {
    300   OperandType type2(Type::TENSOR_INT32, {3});
    301   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2, 3, 1}, 0.5f, 128);
    302   OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 1.0f, 128);
    303   OperandType type4(Type::INT32, {});
    304   OperandType type5(Type::BOOL, {});
    305   OperandType type6(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    306   // Phase 1, operands
    307   auto op11 = model->addOperand(&type22);
    308   auto op21 = model->addOperand(&type6);
    309   auto op31 = model->addOperand(&type2);
    310   auto param7 = model->addOperand(&type4);
    311   auto param8 = model->addOperand(&type4);
    312   auto param9 = model->addOperand(&type4);
    313   auto param10 = model->addOperand(&type4);
    314   auto param11 = model->addOperand(&type4);
    315   auto param12 = model->addOperand(&type4);
    316   auto param13 = model->addOperand(&type4);
    317   auto layout = model->addOperand(&type5);
    318   auto op41 = model->addOperand(&type23);
    319   // Phase 2, operations
    320   static int8_t op21_init[] = {1, 2, 1, 2, 1, 2};
    321   model->setOperandValue(op21, op21_init, sizeof(int8_t) * 6);
    322   static int32_t op31_init[] = {4, 4, 4};
    323   model->setOperandValue(op31, op31_init, sizeof(int32_t) * 3);
    324   static int32_t param7_init[] = {0};
    325   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    326   static int32_t param8_init[] = {0};
    327   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    328   static int32_t param9_init[] = {0};
    329   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    330   static int32_t param10_init[] = {0};
    331   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    332   static int32_t param11_init[] = {1};
    333   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    334   static int32_t param12_init[] = {1};
    335   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    336   static int32_t param13_init[] = {0};
    337   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    338   static bool8 layout_init[] = {true};
    339   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    340   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    341   // Phase 3, inputs and outputs
    342   model->identifyInputsAndOutputs(
    343     {op11},
    344     {op41});
    345   assert(model->isValid());
    346 }
    347 
    348 inline bool is_ignored_layouts_nchw(int i) {
    349   static std::set<int> ignore = {};
    350   return ignore.find(i) != ignore.end();
    351 }
    352 
    353 void CreateModel_layouts_nchw_weight_as_input(Model *model) {
    354   OperandType type2(Type::TENSOR_INT32, {3});
    355   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2, 3, 1}, 0.5f, 128);
    356   OperandType type23(Type::TENSOR_QUANT8_ASYMM, {1, 3, 3, 1}, 1.0f, 128);
    357   OperandType type24(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    358   OperandType type4(Type::INT32, {});
    359   OperandType type5(Type::BOOL, {});
    360   // Phase 1, operands
    361   auto op11 = model->addOperand(&type22);
    362   auto op21 = model->addOperand(&type24);
    363   auto op31 = model->addOperand(&type2);
    364   auto param7 = model->addOperand(&type4);
    365   auto param8 = model->addOperand(&type4);
    366   auto param9 = model->addOperand(&type4);
    367   auto param10 = model->addOperand(&type4);
    368   auto param11 = model->addOperand(&type4);
    369   auto param12 = model->addOperand(&type4);
    370   auto param13 = model->addOperand(&type4);
    371   auto layout = model->addOperand(&type5);
    372   auto op41 = model->addOperand(&type23);
    373   // Phase 2, operations
    374   static int32_t param7_init[] = {0};
    375   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    376   static int32_t param8_init[] = {0};
    377   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    378   static int32_t param9_init[] = {0};
    379   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    380   static int32_t param10_init[] = {0};
    381   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    382   static int32_t param11_init[] = {1};
    383   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    384   static int32_t param12_init[] = {1};
    385   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    386   static int32_t param13_init[] = {0};
    387   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    388   static bool8 layout_init[] = {true};
    389   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    390   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    391   // Phase 3, inputs and outputs
    392   model->identifyInputsAndOutputs(
    393     {op11, op21, op31},
    394     {op41});
    395   assert(model->isValid());
    396 }
    397 
    398 inline bool is_ignored_layouts_nchw_weight_as_input(int i) {
    399   static std::set<int> ignore = {};
    400   return ignore.find(i) != ignore.end();
    401 }
    402 
    403 void CreateModel_layouts_dynamic_output_shape_nhwc(Model *model) {
    404   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    405   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    406   OperandType type2(Type::TENSOR_INT32, {3});
    407   OperandType type4(Type::INT32, {});
    408   OperandType type5(Type::BOOL, {});
    409   OperandType type6(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    410   // Phase 1, operands
    411   auto op11 = model->addOperand(&type0);
    412   auto op21 = model->addOperand(&type6);
    413   auto op31 = model->addOperand(&type2);
    414   auto param7 = model->addOperand(&type4);
    415   auto param8 = model->addOperand(&type4);
    416   auto param9 = model->addOperand(&type4);
    417   auto param10 = model->addOperand(&type4);
    418   auto param11 = model->addOperand(&type4);
    419   auto param12 = model->addOperand(&type4);
    420   auto param13 = model->addOperand(&type4);
    421   auto layout = model->addOperand(&type5);
    422   auto op41 = model->addOperand(&type19);
    423   // Phase 2, operations
    424   static int8_t op21_init[] = {1, 2, 1, 2, 1, 2};
    425   model->setOperandValue(op21, op21_init, sizeof(int8_t) * 6);
    426   static int32_t op31_init[] = {4, 4, 4};
    427   model->setOperandValue(op31, op31_init, sizeof(int32_t) * 3);
    428   static int32_t param7_init[] = {0};
    429   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    430   static int32_t param8_init[] = {0};
    431   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    432   static int32_t param9_init[] = {0};
    433   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    434   static int32_t param10_init[] = {0};
    435   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    436   static int32_t param11_init[] = {1};
    437   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    438   static int32_t param12_init[] = {1};
    439   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    440   static int32_t param13_init[] = {0};
    441   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    442   static bool8 layout_init[] = {false};
    443   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    444   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    445   // Phase 3, inputs and outputs
    446   model->identifyInputsAndOutputs(
    447     {op11},
    448     {op41});
    449   assert(model->isValid());
    450 }
    451 
    452 inline bool is_ignored_layouts_dynamic_output_shape_nhwc(int i) {
    453   static std::set<int> ignore = {};
    454   return ignore.find(i) != ignore.end();
    455 }
    456 
    457 void CreateModel_layouts_dynamic_output_shape_nhwc_weight_as_input(Model *model) {
    458   OperandType type0(Type::TENSOR_QUANT8_ASYMM, {1, 3, 1, 2}, 0.5f, 128);
    459   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    460   OperandType type2(Type::TENSOR_INT32, {3});
    461   OperandType type25(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    462   OperandType type4(Type::INT32, {});
    463   OperandType type5(Type::BOOL, {});
    464   // Phase 1, operands
    465   auto op11 = model->addOperand(&type0);
    466   auto op21 = model->addOperand(&type25);
    467   auto op31 = model->addOperand(&type2);
    468   auto param7 = model->addOperand(&type4);
    469   auto param8 = model->addOperand(&type4);
    470   auto param9 = model->addOperand(&type4);
    471   auto param10 = model->addOperand(&type4);
    472   auto param11 = model->addOperand(&type4);
    473   auto param12 = model->addOperand(&type4);
    474   auto param13 = model->addOperand(&type4);
    475   auto layout = model->addOperand(&type5);
    476   auto op41 = model->addOperand(&type19);
    477   // Phase 2, operations
    478   static int32_t param7_init[] = {0};
    479   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    480   static int32_t param8_init[] = {0};
    481   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    482   static int32_t param9_init[] = {0};
    483   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    484   static int32_t param10_init[] = {0};
    485   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    486   static int32_t param11_init[] = {1};
    487   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    488   static int32_t param12_init[] = {1};
    489   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    490   static int32_t param13_init[] = {0};
    491   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    492   static bool8 layout_init[] = {false};
    493   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    494   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    495   // Phase 3, inputs and outputs
    496   model->identifyInputsAndOutputs(
    497     {op11, op21, op31},
    498     {op41});
    499   assert(model->isValid());
    500 }
    501 
    502 inline bool is_ignored_layouts_dynamic_output_shape_nhwc_weight_as_input(int i) {
    503   static std::set<int> ignore = {};
    504   return ignore.find(i) != ignore.end();
    505 }
    506 
    507 void CreateModel_layouts_dynamic_output_shape_nchw(Model *model) {
    508   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    509   OperandType type2(Type::TENSOR_INT32, {3});
    510   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2, 3, 1}, 0.5f, 128);
    511   OperandType type4(Type::INT32, {});
    512   OperandType type5(Type::BOOL, {});
    513   OperandType type6(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    514   // Phase 1, operands
    515   auto op11 = model->addOperand(&type22);
    516   auto op21 = model->addOperand(&type6);
    517   auto op31 = model->addOperand(&type2);
    518   auto param7 = model->addOperand(&type4);
    519   auto param8 = model->addOperand(&type4);
    520   auto param9 = model->addOperand(&type4);
    521   auto param10 = model->addOperand(&type4);
    522   auto param11 = model->addOperand(&type4);
    523   auto param12 = model->addOperand(&type4);
    524   auto param13 = model->addOperand(&type4);
    525   auto layout = model->addOperand(&type5);
    526   auto op41 = model->addOperand(&type19);
    527   // Phase 2, operations
    528   static int8_t op21_init[] = {1, 2, 1, 2, 1, 2};
    529   model->setOperandValue(op21, op21_init, sizeof(int8_t) * 6);
    530   static int32_t op31_init[] = {4, 4, 4};
    531   model->setOperandValue(op31, op31_init, sizeof(int32_t) * 3);
    532   static int32_t param7_init[] = {0};
    533   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    534   static int32_t param8_init[] = {0};
    535   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    536   static int32_t param9_init[] = {0};
    537   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    538   static int32_t param10_init[] = {0};
    539   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    540   static int32_t param11_init[] = {1};
    541   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    542   static int32_t param12_init[] = {1};
    543   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    544   static int32_t param13_init[] = {0};
    545   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    546   static bool8 layout_init[] = {true};
    547   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    548   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    549   // Phase 3, inputs and outputs
    550   model->identifyInputsAndOutputs(
    551     {op11},
    552     {op41});
    553   assert(model->isValid());
    554 }
    555 
    556 inline bool is_ignored_layouts_dynamic_output_shape_nchw(int i) {
    557   static std::set<int> ignore = {};
    558   return ignore.find(i) != ignore.end();
    559 }
    560 
    561 void CreateModel_layouts_dynamic_output_shape_nchw_weight_as_input(Model *model) {
    562   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    563   OperandType type2(Type::TENSOR_INT32, {3});
    564   OperandType type22(Type::TENSOR_QUANT8_ASYMM, {1, 2, 3, 1}, 0.5f, 128);
    565   OperandType type26(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    566   OperandType type4(Type::INT32, {});
    567   OperandType type5(Type::BOOL, {});
    568   // Phase 1, operands
    569   auto op11 = model->addOperand(&type22);
    570   auto op21 = model->addOperand(&type26);
    571   auto op31 = model->addOperand(&type2);
    572   auto param7 = model->addOperand(&type4);
    573   auto param8 = model->addOperand(&type4);
    574   auto param9 = model->addOperand(&type4);
    575   auto param10 = model->addOperand(&type4);
    576   auto param11 = model->addOperand(&type4);
    577   auto param12 = model->addOperand(&type4);
    578   auto param13 = model->addOperand(&type4);
    579   auto layout = model->addOperand(&type5);
    580   auto op41 = model->addOperand(&type19);
    581   // Phase 2, operations
    582   static int32_t param7_init[] = {0};
    583   model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
    584   static int32_t param8_init[] = {0};
    585   model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
    586   static int32_t param9_init[] = {0};
    587   model->setOperandValue(param9, param9_init, sizeof(int32_t) * 1);
    588   static int32_t param10_init[] = {0};
    589   model->setOperandValue(param10, param10_init, sizeof(int32_t) * 1);
    590   static int32_t param11_init[] = {1};
    591   model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
    592   static int32_t param12_init[] = {1};
    593   model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
    594   static int32_t param13_init[] = {0};
    595   model->setOperandValue(param13, param13_init, sizeof(int32_t) * 1);
    596   static bool8 layout_init[] = {true};
    597   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    598   model->addOperation(ANEURALNETWORKS_CONV_2D, {op11, op21, op31, param7, param8, param9, param10, param11, param12, param13, layout}, {op41});
    599   // Phase 3, inputs and outputs
    600   model->identifyInputsAndOutputs(
    601     {op11, op21, op31},
    602     {op41});
    603   assert(model->isValid());
    604 }
    605 
    606 inline bool is_ignored_layouts_dynamic_output_shape_nchw_weight_as_input(int i) {
    607   static std::set<int> ignore = {};
    608   return ignore.find(i) != ignore.end();
    609 }
    610 
    611 void CreateModel_zero_sized_nhwc(Model *model) {
    612   OperandType type10(Type::TENSOR_INT32, {0});
    613   OperandType type11(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
    614   OperandType type12(Type::TENSOR_INT32, {1});
    615   OperandType type13(Type::FLOAT32, {});
    616   OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 2}, 0.5f, 128);
    617   OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 2}, 0.5f, 128);
    618   OperandType type16(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    619   OperandType type17(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 3}, 1.0f, 128);
    620   OperandType type2(Type::TENSOR_INT32, {3});
    621   OperandType type4(Type::INT32, {});
    622   OperandType type5(Type::BOOL, {});
    623   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
    624   OperandType type8(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
    625   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
    626   // Phase 1, operands
    627   auto scores = model->addOperand(&type7);
    628   auto roi = model->addOperand(&type8);
    629   auto param14 = model->addOperand(&type12);
    630   auto param15 = model->addOperand(&type13);
    631   auto param16 = model->addOperand(&type4);
    632   auto param17 = model->addOperand(&type4);
    633   auto param18 = model->addOperand(&type13);
    634   auto param19 = model->addOperand(&type13);
    635   auto param20 = model->addOperand(&type13);
    636   auto scoresOut = model->addOperand(&type9);
    637   auto roiOut = model->addOperand(&type11);
    638   auto classesOut = model->addOperand(&type10);
    639   auto batchSplitOut = model->addOperand(&type10);
    640   auto in = model->addOperand(&type14);
    641   auto param21 = model->addOperand(&type4);
    642   auto param22 = model->addOperand(&type4);
    643   auto param23 = model->addOperand(&type13);
    644   auto param24 = model->addOperand(&type13);
    645   auto param25 = model->addOperand(&type4);
    646   auto param26 = model->addOperand(&type4);
    647   auto layout = model->addOperand(&type5);
    648   auto featureMap = model->addOperand(&type15);
    649   auto weights = model->addOperand(&type16);
    650   auto bias = model->addOperand(&type2);
    651   auto param27 = model->addOperand(&type4);
    652   auto param28 = model->addOperand(&type4);
    653   auto param29 = model->addOperand(&type4);
    654   auto param30 = model->addOperand(&type4);
    655   auto param31 = model->addOperand(&type4);
    656   auto param32 = model->addOperand(&type4);
    657   auto param33 = model->addOperand(&type4);
    658   auto out = model->addOperand(&type17);
    659   // Phase 2, operations
    660   static uint8_t scores_init[] = {137, 129};
    661   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
    662   static uint16_t roi_init[] = {1, 1, 10, 10, 0, 0, 10, 10};
    663   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
    664   static int32_t param14_init[] = {0};
    665   model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
    666   static float param15_init[] = {0.3f};
    667   model->setOperandValue(param15, param15_init, sizeof(float) * 1);
    668   static int32_t param16_init[] = {-1};
    669   model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
    670   static int32_t param17_init[] = {0};
    671   model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
    672   static float param18_init[] = {0.4f};
    673   model->setOperandValue(param18, param18_init, sizeof(float) * 1);
    674   static float param19_init[] = {1.0f};
    675   model->setOperandValue(param19, param19_init, sizeof(float) * 1);
    676   static float param20_init[] = {0.3f};
    677   model->setOperandValue(param20, param20_init, sizeof(float) * 1);
    678   static int32_t param21_init[] = {2};
    679   model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
    680   static int32_t param22_init[] = {2};
    681   model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
    682   static float param23_init[] = {2.0f};
    683   model->setOperandValue(param23, param23_init, sizeof(float) * 1);
    684   static float param24_init[] = {2.0f};
    685   model->setOperandValue(param24, param24_init, sizeof(float) * 1);
    686   static int32_t param25_init[] = {4};
    687   model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
    688   static int32_t param26_init[] = {4};
    689   model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
    690   static bool8 layout_init[] = {false};
    691   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    692   static int8_t weights_init[] = {1, 2, 1, 2, 1, 2};
    693   model->setOperandValue(weights, weights_init, sizeof(int8_t) * 6);
    694   static int32_t bias_init[] = {4, 4, 4};
    695   model->setOperandValue(bias, bias_init, sizeof(int32_t) * 3);
    696   static int32_t param27_init[] = {0};
    697   model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
    698   static int32_t param28_init[] = {0};
    699   model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
    700   static int32_t param29_init[] = {0};
    701   model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
    702   static int32_t param30_init[] = {0};
    703   model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
    704   static int32_t param31_init[] = {1};
    705   model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
    706   static int32_t param32_init[] = {1};
    707   model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
    708   static int32_t param33_init[] = {0};
    709   model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
    710   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param14, param15, param16, param17, param18, param19, param20}, {scoresOut, roiOut, classesOut, batchSplitOut});
    711   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param21, param22, param23, param24, param25, param26, layout}, {featureMap});
    712   model->addOperation(ANEURALNETWORKS_CONV_2D, {featureMap, weights, bias, param27, param28, param29, param30, param31, param32, param33, layout}, {out});
    713   // Phase 3, inputs and outputs
    714   model->identifyInputsAndOutputs(
    715     {in},
    716     {scoresOut, classesOut, out});
    717   assert(model->isValid());
    718 }
    719 
    720 inline bool is_ignored_zero_sized_nhwc(int i) {
    721   static std::set<int> ignore = {};
    722   return ignore.find(i) != ignore.end();
    723 }
    724 
    725 void CreateModel_zero_sized_nchw(Model *model) {
    726   OperandType type10(Type::TENSOR_INT32, {0});
    727   OperandType type11(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
    728   OperandType type12(Type::TENSOR_INT32, {1});
    729   OperandType type13(Type::FLOAT32, {});
    730   OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 2}, 0.5f, 128);
    731   OperandType type16(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    732   OperandType type2(Type::TENSOR_INT32, {3});
    733   OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 2, 1, 1}, 0.5f, 128);
    734   OperandType type28(Type::TENSOR_QUANT8_ASYMM, {0, 3, 2, 2}, 1.0f, 128);
    735   OperandType type4(Type::INT32, {});
    736   OperandType type5(Type::BOOL, {});
    737   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
    738   OperandType type8(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
    739   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
    740   // Phase 1, operands
    741   auto scores = model->addOperand(&type7);
    742   auto roi = model->addOperand(&type8);
    743   auto param14 = model->addOperand(&type12);
    744   auto param15 = model->addOperand(&type13);
    745   auto param16 = model->addOperand(&type4);
    746   auto param17 = model->addOperand(&type4);
    747   auto param18 = model->addOperand(&type13);
    748   auto param19 = model->addOperand(&type13);
    749   auto param20 = model->addOperand(&type13);
    750   auto scoresOut = model->addOperand(&type9);
    751   auto roiOut = model->addOperand(&type11);
    752   auto classesOut = model->addOperand(&type10);
    753   auto batchSplitOut = model->addOperand(&type10);
    754   auto in = model->addOperand(&type27);
    755   auto param21 = model->addOperand(&type4);
    756   auto param22 = model->addOperand(&type4);
    757   auto param23 = model->addOperand(&type13);
    758   auto param24 = model->addOperand(&type13);
    759   auto param25 = model->addOperand(&type4);
    760   auto param26 = model->addOperand(&type4);
    761   auto layout = model->addOperand(&type5);
    762   auto featureMap = model->addOperand(&type15);
    763   auto weights = model->addOperand(&type16);
    764   auto bias = model->addOperand(&type2);
    765   auto param27 = model->addOperand(&type4);
    766   auto param28 = model->addOperand(&type4);
    767   auto param29 = model->addOperand(&type4);
    768   auto param30 = model->addOperand(&type4);
    769   auto param31 = model->addOperand(&type4);
    770   auto param32 = model->addOperand(&type4);
    771   auto param33 = model->addOperand(&type4);
    772   auto out = model->addOperand(&type28);
    773   // Phase 2, operations
    774   static uint8_t scores_init[] = {137, 129};
    775   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
    776   static uint16_t roi_init[] = {1, 1, 10, 10, 0, 0, 10, 10};
    777   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
    778   static int32_t param14_init[] = {0};
    779   model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
    780   static float param15_init[] = {0.3f};
    781   model->setOperandValue(param15, param15_init, sizeof(float) * 1);
    782   static int32_t param16_init[] = {-1};
    783   model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
    784   static int32_t param17_init[] = {0};
    785   model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
    786   static float param18_init[] = {0.4f};
    787   model->setOperandValue(param18, param18_init, sizeof(float) * 1);
    788   static float param19_init[] = {1.0f};
    789   model->setOperandValue(param19, param19_init, sizeof(float) * 1);
    790   static float param20_init[] = {0.3f};
    791   model->setOperandValue(param20, param20_init, sizeof(float) * 1);
    792   static int32_t param21_init[] = {2};
    793   model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
    794   static int32_t param22_init[] = {2};
    795   model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
    796   static float param23_init[] = {2.0f};
    797   model->setOperandValue(param23, param23_init, sizeof(float) * 1);
    798   static float param24_init[] = {2.0f};
    799   model->setOperandValue(param24, param24_init, sizeof(float) * 1);
    800   static int32_t param25_init[] = {4};
    801   model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
    802   static int32_t param26_init[] = {4};
    803   model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
    804   static bool8 layout_init[] = {true};
    805   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    806   static int8_t weights_init[] = {1, 2, 1, 2, 1, 2};
    807   model->setOperandValue(weights, weights_init, sizeof(int8_t) * 6);
    808   static int32_t bias_init[] = {4, 4, 4};
    809   model->setOperandValue(bias, bias_init, sizeof(int32_t) * 3);
    810   static int32_t param27_init[] = {0};
    811   model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
    812   static int32_t param28_init[] = {0};
    813   model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
    814   static int32_t param29_init[] = {0};
    815   model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
    816   static int32_t param30_init[] = {0};
    817   model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
    818   static int32_t param31_init[] = {1};
    819   model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
    820   static int32_t param32_init[] = {1};
    821   model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
    822   static int32_t param33_init[] = {0};
    823   model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
    824   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param14, param15, param16, param17, param18, param19, param20}, {scoresOut, roiOut, classesOut, batchSplitOut});
    825   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param21, param22, param23, param24, param25, param26, layout}, {featureMap});
    826   model->addOperation(ANEURALNETWORKS_CONV_2D, {featureMap, weights, bias, param27, param28, param29, param30, param31, param32, param33, layout}, {out});
    827   // Phase 3, inputs and outputs
    828   model->identifyInputsAndOutputs(
    829     {in},
    830     {scoresOut, classesOut, out});
    831   assert(model->isValid());
    832 }
    833 
    834 inline bool is_ignored_zero_sized_nchw(int i) {
    835   static std::set<int> ignore = {};
    836   return ignore.find(i) != ignore.end();
    837 }
    838 
    839 void CreateModel_zero_sized_dynamic_output_shape_nhwc(Model *model) {
    840   OperandType type10(Type::TENSOR_INT32, {0});
    841   OperandType type11(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
    842   OperandType type12(Type::TENSOR_INT32, {1});
    843   OperandType type13(Type::FLOAT32, {});
    844   OperandType type14(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 2}, 0.5f, 128);
    845   OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 2}, 0.5f, 128);
    846   OperandType type16(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    847   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    848   OperandType type2(Type::TENSOR_INT32, {3});
    849   OperandType type4(Type::INT32, {});
    850   OperandType type5(Type::BOOL, {});
    851   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
    852   OperandType type8(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
    853   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
    854   // Phase 1, operands
    855   auto scores = model->addOperand(&type7);
    856   auto roi = model->addOperand(&type8);
    857   auto param14 = model->addOperand(&type12);
    858   auto param15 = model->addOperand(&type13);
    859   auto param16 = model->addOperand(&type4);
    860   auto param17 = model->addOperand(&type4);
    861   auto param18 = model->addOperand(&type13);
    862   auto param19 = model->addOperand(&type13);
    863   auto param20 = model->addOperand(&type13);
    864   auto scoresOut = model->addOperand(&type9);
    865   auto roiOut = model->addOperand(&type11);
    866   auto classesOut = model->addOperand(&type10);
    867   auto batchSplitOut = model->addOperand(&type10);
    868   auto in = model->addOperand(&type14);
    869   auto param21 = model->addOperand(&type4);
    870   auto param22 = model->addOperand(&type4);
    871   auto param23 = model->addOperand(&type13);
    872   auto param24 = model->addOperand(&type13);
    873   auto param25 = model->addOperand(&type4);
    874   auto param26 = model->addOperand(&type4);
    875   auto layout = model->addOperand(&type5);
    876   auto featureMap = model->addOperand(&type15);
    877   auto weights = model->addOperand(&type16);
    878   auto bias = model->addOperand(&type2);
    879   auto param27 = model->addOperand(&type4);
    880   auto param28 = model->addOperand(&type4);
    881   auto param29 = model->addOperand(&type4);
    882   auto param30 = model->addOperand(&type4);
    883   auto param31 = model->addOperand(&type4);
    884   auto param32 = model->addOperand(&type4);
    885   auto param33 = model->addOperand(&type4);
    886   auto out = model->addOperand(&type19);
    887   // Phase 2, operations
    888   static uint8_t scores_init[] = {137, 129};
    889   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
    890   static uint16_t roi_init[] = {1, 1, 10, 10, 0, 0, 10, 10};
    891   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
    892   static int32_t param14_init[] = {0};
    893   model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
    894   static float param15_init[] = {0.3f};
    895   model->setOperandValue(param15, param15_init, sizeof(float) * 1);
    896   static int32_t param16_init[] = {-1};
    897   model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
    898   static int32_t param17_init[] = {0};
    899   model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
    900   static float param18_init[] = {0.4f};
    901   model->setOperandValue(param18, param18_init, sizeof(float) * 1);
    902   static float param19_init[] = {1.0f};
    903   model->setOperandValue(param19, param19_init, sizeof(float) * 1);
    904   static float param20_init[] = {0.3f};
    905   model->setOperandValue(param20, param20_init, sizeof(float) * 1);
    906   static int32_t param21_init[] = {2};
    907   model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
    908   static int32_t param22_init[] = {2};
    909   model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
    910   static float param23_init[] = {2.0f};
    911   model->setOperandValue(param23, param23_init, sizeof(float) * 1);
    912   static float param24_init[] = {2.0f};
    913   model->setOperandValue(param24, param24_init, sizeof(float) * 1);
    914   static int32_t param25_init[] = {4};
    915   model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
    916   static int32_t param26_init[] = {4};
    917   model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
    918   static bool8 layout_init[] = {false};
    919   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
    920   static int8_t weights_init[] = {1, 2, 1, 2, 1, 2};
    921   model->setOperandValue(weights, weights_init, sizeof(int8_t) * 6);
    922   static int32_t bias_init[] = {4, 4, 4};
    923   model->setOperandValue(bias, bias_init, sizeof(int32_t) * 3);
    924   static int32_t param27_init[] = {0};
    925   model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
    926   static int32_t param28_init[] = {0};
    927   model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
    928   static int32_t param29_init[] = {0};
    929   model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
    930   static int32_t param30_init[] = {0};
    931   model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
    932   static int32_t param31_init[] = {1};
    933   model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
    934   static int32_t param32_init[] = {1};
    935   model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
    936   static int32_t param33_init[] = {0};
    937   model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
    938   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param14, param15, param16, param17, param18, param19, param20}, {scoresOut, roiOut, classesOut, batchSplitOut});
    939   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param21, param22, param23, param24, param25, param26, layout}, {featureMap});
    940   model->addOperation(ANEURALNETWORKS_CONV_2D, {featureMap, weights, bias, param27, param28, param29, param30, param31, param32, param33, layout}, {out});
    941   // Phase 3, inputs and outputs
    942   model->identifyInputsAndOutputs(
    943     {in},
    944     {scoresOut, classesOut, out});
    945   assert(model->isValid());
    946 }
    947 
    948 inline bool is_ignored_zero_sized_dynamic_output_shape_nhwc(int i) {
    949   static std::set<int> ignore = {};
    950   return ignore.find(i) != ignore.end();
    951 }
    952 
    953 void CreateModel_zero_sized_dynamic_output_shape_nchw(Model *model) {
    954   OperandType type10(Type::TENSOR_INT32, {0});
    955   OperandType type11(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
    956   OperandType type12(Type::TENSOR_INT32, {1});
    957   OperandType type13(Type::FLOAT32, {});
    958   OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 2}, 0.5f, 128);
    959   OperandType type16(Type::TENSOR_QUANT8_SYMM_PER_CHANNEL, {3, 1, 1, 2}, 0.0f, 0, SymmPerChannelQuantParams({0.5f, 0.75f, 1.0f},0));
    960   OperandType type19(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 1.0f, 128);
    961   OperandType type2(Type::TENSOR_INT32, {3});
    962   OperandType type27(Type::TENSOR_QUANT8_ASYMM, {1, 2, 1, 1}, 0.5f, 128);
    963   OperandType type4(Type::INT32, {});
    964   OperandType type5(Type::BOOL, {});
    965   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
    966   OperandType type8(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
    967   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
    968   // Phase 1, operands
    969   auto scores = model->addOperand(&type7);
    970   auto roi = model->addOperand(&type8);
    971   auto param14 = model->addOperand(&type12);
    972   auto param15 = model->addOperand(&type13);
    973   auto param16 = model->addOperand(&type4);
    974   auto param17 = model->addOperand(&type4);
    975   auto param18 = model->addOperand(&type13);
    976   auto param19 = model->addOperand(&type13);
    977   auto param20 = model->addOperand(&type13);
    978   auto scoresOut = model->addOperand(&type9);
    979   auto roiOut = model->addOperand(&type11);
    980   auto classesOut = model->addOperand(&type10);
    981   auto batchSplitOut = model->addOperand(&type10);
    982   auto in = model->addOperand(&type27);
    983   auto param21 = model->addOperand(&type4);
    984   auto param22 = model->addOperand(&type4);
    985   auto param23 = model->addOperand(&type13);
    986   auto param24 = model->addOperand(&type13);
    987   auto param25 = model->addOperand(&type4);
    988   auto param26 = model->addOperand(&type4);
    989   auto layout = model->addOperand(&type5);
    990   auto featureMap = model->addOperand(&type15);
    991   auto weights = model->addOperand(&type16);
    992   auto bias = model->addOperand(&type2);
    993   auto param27 = model->addOperand(&type4);
    994   auto param28 = model->addOperand(&type4);
    995   auto param29 = model->addOperand(&type4);
    996   auto param30 = model->addOperand(&type4);
    997   auto param31 = model->addOperand(&type4);
    998   auto param32 = model->addOperand(&type4);
    999   auto param33 = model->addOperand(&type4);
   1000   auto out = model->addOperand(&type19);
   1001   // Phase 2, operations
   1002   static uint8_t scores_init[] = {137, 129};
   1003   model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
   1004   static uint16_t roi_init[] = {1, 1, 10, 10, 0, 0, 10, 10};
   1005   model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
   1006   static int32_t param14_init[] = {0};
   1007   model->setOperandValue(param14, param14_init, sizeof(int32_t) * 1);
   1008   static float param15_init[] = {0.3f};
   1009   model->setOperandValue(param15, param15_init, sizeof(float) * 1);
   1010   static int32_t param16_init[] = {-1};
   1011   model->setOperandValue(param16, param16_init, sizeof(int32_t) * 1);
   1012   static int32_t param17_init[] = {0};
   1013   model->setOperandValue(param17, param17_init, sizeof(int32_t) * 1);
   1014   static float param18_init[] = {0.4f};
   1015   model->setOperandValue(param18, param18_init, sizeof(float) * 1);
   1016   static float param19_init[] = {1.0f};
   1017   model->setOperandValue(param19, param19_init, sizeof(float) * 1);
   1018   static float param20_init[] = {0.3f};
   1019   model->setOperandValue(param20, param20_init, sizeof(float) * 1);
   1020   static int32_t param21_init[] = {2};
   1021   model->setOperandValue(param21, param21_init, sizeof(int32_t) * 1);
   1022   static int32_t param22_init[] = {2};
   1023   model->setOperandValue(param22, param22_init, sizeof(int32_t) * 1);
   1024   static float param23_init[] = {2.0f};
   1025   model->setOperandValue(param23, param23_init, sizeof(float) * 1);
   1026   static float param24_init[] = {2.0f};
   1027   model->setOperandValue(param24, param24_init, sizeof(float) * 1);
   1028   static int32_t param25_init[] = {4};
   1029   model->setOperandValue(param25, param25_init, sizeof(int32_t) * 1);
   1030   static int32_t param26_init[] = {4};
   1031   model->setOperandValue(param26, param26_init, sizeof(int32_t) * 1);
   1032   static bool8 layout_init[] = {true};
   1033   model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
   1034   static int8_t weights_init[] = {1, 2, 1, 2, 1, 2};
   1035   model->setOperandValue(weights, weights_init, sizeof(int8_t) * 6);
   1036   static int32_t bias_init[] = {4, 4, 4};
   1037   model->setOperandValue(bias, bias_init, sizeof(int32_t) * 3);
   1038   static int32_t param27_init[] = {0};
   1039   model->setOperandValue(param27, param27_init, sizeof(int32_t) * 1);
   1040   static int32_t param28_init[] = {0};
   1041   model->setOperandValue(param28, param28_init, sizeof(int32_t) * 1);
   1042   static int32_t param29_init[] = {0};
   1043   model->setOperandValue(param29, param29_init, sizeof(int32_t) * 1);
   1044   static int32_t param30_init[] = {0};
   1045   model->setOperandValue(param30, param30_init, sizeof(int32_t) * 1);
   1046   static int32_t param31_init[] = {1};
   1047   model->setOperandValue(param31, param31_init, sizeof(int32_t) * 1);
   1048   static int32_t param32_init[] = {1};
   1049   model->setOperandValue(param32, param32_init, sizeof(int32_t) * 1);
   1050   static int32_t param33_init[] = {0};
   1051   model->setOperandValue(param33, param33_init, sizeof(int32_t) * 1);
   1052   model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param14, param15, param16, param17, param18, param19, param20}, {scoresOut, roiOut, classesOut, batchSplitOut});
   1053   model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param21, param22, param23, param24, param25, param26, layout}, {featureMap});
   1054   model->addOperation(ANEURALNETWORKS_CONV_2D, {featureMap, weights, bias, param27, param28, param29, param30, param31, param32, param33, layout}, {out});
   1055   // Phase 3, inputs and outputs
   1056   model->identifyInputsAndOutputs(
   1057     {in},
   1058     {scoresOut, classesOut, out});
   1059   assert(model->isValid());
   1060 }
   1061 
   1062 inline bool is_ignored_zero_sized_dynamic_output_shape_nchw(int i) {
   1063   static std::set<int> ignore = {};
   1064   return ignore.find(i) != ignore.end();
   1065 }
   1066 
   1067