nihui
/
ncnn
Not watched
1
0
Fork 0
Code
Releases 46 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: bedf00a5ed
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bedf00a5ed'
${ noResults }
ncnn/tools/onnx/onnx2ncnn.cpp

3469 lines
117 kB
Raw Blame History 

  1. // Tencent is pleased to support the open source community by making ncnn available.

  2. //

  3. // Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.

  4. //

  5. // Licensed under the BSD 3-Clause License (the "License"); you may not use this file except

  6. // in compliance with the License. You may obtain a copy of the License at

  7. //

  8. // https://opensource.org/licenses/BSD-3-Clause

  9. //

  10. // Unless required by applicable law or agreed to in writing, software distributed

  11. // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

  12. // CONDITIONS OF ANY KIND, either express or implied. See the License for the

  13. // specific language governing permissions and limitations under the License.

  14. 

  15. #include "onnx.pb.h"

  16. 

  17. #include <algorithm>

  18. #include <float.h>

  19. #include <fstream>

  20. #include <google/protobuf/io/coded_stream.h>

  21. #include <google/protobuf/io/zero_copy_stream_impl.h>

  22. #include <google/protobuf/message.h>

  23. #include <google/protobuf/text_format.h>

  24. #include <iostream>

  25. #include <limits.h>

  26. #include <limits>

  27. #include <set>

  28. #include <stdio.h>

  29. 

  30. static bool read_proto_from_binary(const char* filepath, google::protobuf::Message* message)

  31. {

  32.     std::ifstream fs(filepath, std::ifstream::in | std::ifstream::binary);

  33.     if (!fs.is_open())

  34.     {

  35.         fprintf(stderr, "open failed %s\n", filepath);

  36.         return false;

  37.     }

  38. 

  39.     google::protobuf::io::IstreamInputStream input(&fs);

  40.     google::protobuf::io::CodedInputStream codedstr(&input);

  41. 

  42.     codedstr.SetTotalBytesLimit(INT_MAX, INT_MAX / 2);

  43. 

  44.     bool success = message->ParseFromCodedStream(&codedstr);

  45. 

  46.     fs.close();

  47. 

  48.     return success;

  49. }

  50. 

  51. static std::vector<int> get_node_attr_ai(const onnx::NodeProto& node, const char* key)

  52. {

  53.     std::vector<int> v;

  54. 

  55.     for (int i = 0; i < node.attribute_size(); i++)

  56.     {

  57.         const onnx::AttributeProto& attr = node.attribute(i);

  58.         if (attr.name() == key)

  59.         {

  60.             v.resize(attr.ints_size());

  61.             for (int j = 0; j < attr.ints_size(); j++)

  62.             {

  63.                 v[j] = std::max(std::min(attr.ints(j), (::google::protobuf::int64)INT_MAX), (::google::protobuf::int64)INT_MIN);

  64.             }

  65. 

  66.             break;

  67.         }

  68.     }

  69. 

  70.     return v;

  71. }

  72. 

  73. static std::vector<float> get_node_attr_af(const onnx::NodeProto& node, const char* key)

  74. {

  75.     std::vector<float> v;

  76. 

  77.     for (int i = 0; i < node.attribute_size(); i++)

  78.     {

  79.         const onnx::AttributeProto& attr = node.attribute(i);

  80.         if (attr.name() == key)

  81.         {

  82.             v.resize(attr.floats_size());

  83.             for (int j = 0; j < attr.floats_size(); j++)

  84.             {

  85.                 v[j] = attr.floats(j);

  86.             }

  87. 

  88.             break;

  89.         }

  90.     }

  91. 

  92.     return v;

  93. }

  94. 

  95. static int get_node_attr_i(const onnx::NodeProto& node, const char* key, int def = 0)

  96. {

  97.     for (int i = 0; i < node.attribute_size(); i++)

  98.     {

  99.         const onnx::AttributeProto& attr = node.attribute(i);

  100.         if (attr.name() == key)

  101.         {

  102.             return std::max(std::min(attr.i(), (::google::protobuf::int64)INT_MAX), (::google::protobuf::int64)INT_MIN);

  103.         }

  104.     }

  105. 

  106.     return def;

  107. }

  108. 

  109. static float get_node_attr_f(const onnx::NodeProto& node, const char* key, float def = 0.f)

  110. {

  111.     for (int i = 0; i < node.attribute_size(); i++)

  112.     {

  113.         const onnx::AttributeProto& attr = node.attribute(i);

  114.         if (attr.name() == key)

  115.         {

  116.             return attr.f();

  117.         }

  118.     }

  119. 

  120.     return def;

  121. }

  122. 

  123. static std::string get_node_attr_s(const onnx::NodeProto& node, const char* key, const std::string& def = std::string())

  124. {

  125.     for (int i = 0; i < node.attribute_size(); i++)

  126.     {

  127.         const onnx::AttributeProto& attr = node.attribute(i);

  128.         if (attr.name() == key)

  129.         {

  130.             return attr.s();

  131.         }

  132.     }

  133. 

  134.     return def;

  135. }

  136. 

  137. static onnx::TensorProto get_node_attr_tensor(const onnx::NodeProto& node, const char* key)

  138. {

  139.     for (int i = 0; i < node.attribute_size(); i++)

  140.     {

  141.         const onnx::AttributeProto& attr = node.attribute(i);

  142.         if (attr.name() == key)

  143.         {

  144.             return attr.t();

  145.         }

  146.     }

  147. 

  148.     return onnx::TensorProto();

  149. }

  150. 

  151. static std::vector<int> get_node_attr_from_input_ai(const onnx::TensorProto& tp)

  152. {

  153.     int size = 0;

  154. 

  155.     std::vector<int> v;

  156. 

  157.     // int64

  158.     if (tp.data_type() == 7)

  159.     {

  160.         const int64_t* shape_data = 0;

  161.         if (tp.has_raw_data())

  162.         {

  163.             shape_data = (const int64_t*)tp.raw_data().data();

  164.             size = tp.raw_data().size() / 8;

  165.         }

  166.         else

  167.         {

  168.             shape_data = tp.int64_data().data();

  169.             size = tp.int64_data_size();

  170.         }

  171.         for (int j = 0; j < size; j++)

  172.         {

  173.             v.push_back(shape_data[j]);

  174.         }

  175.     }

  176.     // int32

  177.     else if (tp.data_type() == 6)

  178.     {

  179.         const int32_t* shape_data = 0;

  180.         if (tp.has_raw_data())

  181.         {

  182.             shape_data = (const int32_t*)tp.raw_data().data();

  183.             size = tp.raw_data().size() / 4;

  184.         }

  185.         else

  186.         {

  187.             shape_data = tp.int32_data().data();

  188.             size = tp.int32_data_size();

  189.         }

  190.         for (int j = 0; j < size; j++)

  191.         {

  192.             v.push_back(shape_data[j]);

  193.         }

  194.     }

  195.     else

  196.     {

  197.         fprintf(stderr, "Unknown data type %d\n", tp.data_type());

  198.     }

  199. 

  200.     return v;

  201. }

  202. 

  203. static std::vector<float> get_node_attr_from_input_af(const onnx::TensorProto& tp)

  204. {

  205.     int size = 0;

  206. 

  207.     std::vector<float> v;

  208. 

  209.     // float

  210.     if (tp.data_type() == 1)

  211.     {

  212.         const float* shape_data = 0;

  213.         if (tp.has_raw_data())

  214.         {

  215.             shape_data = (const float*)tp.raw_data().data();

  216.             size = tp.raw_data().size() / 4;

  217.         }

  218.         else

  219.         {

  220.             shape_data = tp.float_data().data();

  221.             size = tp.float_data_size();

  222.         }

  223.         for (int j = 0; j < size; j++)

  224.         {

  225.             v.push_back(shape_data[j]);

  226.         }

  227.     }

  228.     // double

  229.     else if (tp.data_type() == 11)

  230.     {

  231.         const double* shape_data = 0;

  232.         if (tp.has_raw_data())

  233.         {

  234.             shape_data = (const double*)tp.raw_data().data();

  235.             size = tp.raw_data().size() / 8;

  236.         }

  237.         else

  238.         {

  239.             shape_data = tp.double_data().data();

  240.             size = tp.double_data_size();

  241.         }

  242.         for (int j = 0; j < size; j++)

  243.         {

  244.             v.push_back((float)shape_data[j]);

  245.         }

  246.     }

  247.     else

  248.     {

  249.         fprintf(stderr, "Unknown data type %d\n", tp.data_type());

  250.     }

  251. 

  252.     return v;

  253. }

  254. 

  255. static int get_tensor_proto_data_size(const onnx::TensorProto& tp)

  256. {

  257.     if (tp.has_raw_data())

  258.     {

  259.         const std::string& raw_data = tp.raw_data();

  260.         int size = (int)raw_data.size() / 4;

  261.         return size;

  262.     }

  263.     else if (tp.data_type() == 1)

  264.     {

  265.         return tp.float_data_size();

  266.     }

  267. 

  268.     return 0;

  269. }

  270. 

  271. static void fwrite_tensor_proto_data(const onnx::TensorProto& tp, FILE* bp)

  272. {

  273.     int size = get_tensor_proto_data_size(tp);

  274. 

  275.     if (tp.has_raw_data())

  276.     {

  277.         const std::string& raw_data = tp.raw_data();

  278.         fwrite(raw_data.data(), sizeof(float), size, bp);

  279.     }

  280.     else if (tp.data_type() == 1)

  281.     {

  282.         fwrite(tp.float_data().data(), sizeof(float), size, bp);

  283.     }

  284. }

  285. 

  286. static void fuse_matmul(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  287. {

  288.     int node_count = mutable_graph->node_size();

  289.     for (int i = 0; i < node_count; i++)

  290.     {

  291.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  292. 

  293.         // MatMul <= Transpose(weight) - MatMul

  294.         if (node->op_type() == "Transpose")

  295.         {

  296.             // check weight

  297.             if (weights.find(node->input(0)) == weights.end())

  298.                 continue;

  299. 

  300.             onnx::TensorProto& B = weights[node->input(0)];

  301.             if (B.dims_size() != 2)

  302.                 continue;

  303. 

  304.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  305.                 continue;

  306. 

  307.             // perm = (1, 0)

  308.             std::vector<int> perm = get_node_attr_ai(*node, "perm");

  309.             if (perm.size() != 2)

  310.                 continue;

  311.             if (perm[0] != 1 || perm[1] != 0)

  312.                 continue;

  313. 

  314.             if (i + 1 >= node_count)

  315.                 continue;

  316. 

  317.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  318. 

  319.             if (node2->op_type() != "MatMul")

  320.                 continue;

  321. 

  322.             // reduce

  323.             node->set_op_type("noop_reducedncnn");

  324. 

  325.             node_reference.erase(node_reference.find(node->output(0)));

  326.             blob_names.erase(node->output(0));

  327. 

  328.             node2->set_input(1, node->input(0));

  329. 

  330.             // permute weight

  331.             {

  332.                 const int h = B.dims(0);

  333.                 const int w = B.dims(1);

  334. 

  335.                 std::vector<float> permuted_data;

  336.                 permuted_data.reserve(h * w);

  337.                 const float* bptr = B.has_raw_data() ? (const float*)B.raw_data().data() : B.float_data().data();

  338. 

  339.                 for (int j = 0; j < w; j++)

  340.                 {

  341.                     for (int k = 0; k < h; k++)

  342.                     {

  343.                         float vb = bptr[k * w + j];

  344.                         permuted_data.push_back(vb);

  345.                     }

  346.                 }

  347. 

  348.                 B.set_dims(0, w);

  349.                 B.set_dims(1, h);

  350. 

  351.                 if (B.has_raw_data())

  352.                 {

  353.                     B.set_raw_data(permuted_data.data(), permuted_data.size() * sizeof(float));

  354.                 }

  355.                 else

  356.                 {

  357.                     for (int j = 0; j < (int)permuted_data.size(); j++)

  358.                         B.set_float_data(j, permuted_data[j]);

  359.                 }

  360.             }

  361. 

  362.             reduced_node_count += 1;

  363.             i += 1;

  364.         }

  365.     }

  366. }

  367. 

  368. static void fuse_shufflechannel(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  369. {

  370.     int node_count = mutable_graph->node_size();

  371.     for (int i = 0; i < node_count; i++)

  372.     {

  373.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  374. 

  375.         // ShuffleChannel <= Reshape - Transpose - Reshape

  376.         // ShuffleChannel <= Reshape - Transpose - Constant - Reshape

  377.         if (node->op_type() == "Reshape")

  378.         {

  379.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  380.                 continue;

  381. 

  382.             std::vector<int> shape;

  383.             if (node->input_size() == 1)

  384.             {

  385.                 shape = get_node_attr_ai(*node, "shape");

  386.             }

  387.             else

  388.             {

  389.                 // skip weight reshape

  390.                 if (weights.find(node->input(1)) == weights.end())

  391.                     continue;

  392. 

  393.                 shape = get_node_attr_from_input_ai(weights[node->input(1)]);

  394.             }

  395. 

  396.             // 1 groups channels_per_group, height, width

  397.             // reverse style = channels_per_group, groups, height * width

  398.             if (shape.size() != 5 && shape.size() != 3)

  399.                 continue;

  400. 

  401.             if (shape.size() == 5 && shape[0] != 1)

  402.                 continue;

  403. 

  404.             if (i + 2 >= node_count)

  405.                 continue;

  406. 

  407.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  408.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  409. 

  410.             if (node3->op_type() == "Constant")

  411.             {

  412.                 if (i + 3 >= node_count)

  413.                     continue;

  414. 

  415.                 node3 = mutable_graph->mutable_node(i + 3);

  416.             }

  417. 

  418.             if (node2->op_type() != "Transpose" || node3->op_type() != "Reshape")

  419.                 continue;

  420. 

  421.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  422.                 continue;

  423. 

  424.             // 0 2 1 3 4

  425.             // reverse style = 1 0 2

  426.             std::vector<int> perm = get_node_attr_ai(*node2, "perm");

  427.             if (perm.size() != 5 && perm.size() != 3)

  428.                 continue;

  429. 

  430.             if (perm.size() == 5 && (perm[0] != 0 || perm[1] != 2 || perm[2] != 1 || perm[3] != 3 || perm[4] != 4))

  431.                 continue;

  432. 

  433.             if (perm.size() == 3 && (perm[0] != 1 || perm[1] != 0 || perm[2] != 2))

  434.                 continue;

  435. 

  436.             std::vector<int> shape3;

  437.             if (node3->input_size() == 1)

  438.             {

  439.                 shape3 = get_node_attr_ai(*node3, "shape");

  440.             }

  441.             else

  442.             {

  443.                 // skip weight reshape

  444.                 if (weights.find(node3->input(1)) == weights.end())

  445.                     continue;

  446. 

  447.                 shape3 = get_node_attr_from_input_ai(weights[node3->input(1)]);

  448.             }

  449. 

  450.             // 1, -1, height, width

  451.             // reverse style = group, -1, channels_per_group, height, width

  452.             if (shape3.size() != 4 && shape3.size() != 5)

  453.                 continue;

  454. 

  455.             if (shape3.size() == 4 && (shape3[0] != 1 || (shape3[1] != -1 && shape3[1] != shape[1] * shape[2])))

  456.                 continue;

  457. 

  458.             if (shape3.size() == 5 && (shape3[0] != shape[1] || shape3[2] != shape[0] || shape3[3] * shape3[4] != shape[2]))

  459.                 continue;

  460. 

  461.             // reduce

  462.             node->set_op_type("noop_reducedncnn");

  463.             node2->set_op_type("noop_reducedncnn");

  464. 

  465.             node_reference.erase(node_reference.find(node->output(0)));

  466.             node_reference.erase(node_reference.find(node2->output(0)));

  467.             blob_names.erase(node->output(0));

  468.             blob_names.erase(node2->output(0));

  469. 

  470.             node3->set_op_type("ShuffleChannel");

  471.             node3->set_input(0, node->input(0));

  472. 

  473.             onnx::AttributeProto* attr_group = node3->add_attribute();

  474.             attr_group->set_name("group");

  475.             attr_group->set_i(shape[1]);

  476. 

  477.             onnx::AttributeProto* attr_reverse = node3->add_attribute();

  478.             attr_reverse->set_name("reverse");

  479.             attr_reverse->set_i(shape.size() == 3);

  480. 

  481.             reduced_node_count += 2;

  482.             i += 2;

  483.         }

  484.     }

  485. }

  486. 

  487. static void fuse_shufflechannel_split(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  488. {

  489.     int node_count = mutable_graph->node_size();

  490.     for (int i = 0; i < node_count; i++)

  491.     {

  492.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  493. 

  494.         // Split <= ShuffleChannel(reverse type) - Gather(0) - Gather(1)

  495.         if (node->op_type() == "ShuffleChannel")

  496.         {

  497.             // reverse = 1

  498.             int reverse = get_node_attr_i(*node, "reverse");

  499.             if (reverse != 1)

  500.                 continue;

  501. 

  502.             if (i + 2 >= node_count)

  503.                 continue;

  504. 

  505.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  506.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  507. 

  508.             if (node2->op_type() != "Gather" || node3->op_type() != "Gather")

  509.                 continue;

  510. 

  511.             if (node2->input(0) != node->output(0) || node3->input(0) != node->output(0))

  512.                 continue;

  513. 

  514.             // axis = 0

  515.             int gather2_axis = get_node_attr_i(*node2, "axis");

  516.             if (gather2_axis != 0)

  517.                 continue;

  518. 

  519.             // indices = 0

  520.             if (weights.find(node2->input(1)) == weights.end())

  521.                 continue;

  522. 

  523.             std::vector<int> gather2_indices = get_node_attr_from_input_ai(weights[node2->input(1)]);

  524.             if (gather2_indices.size() != 1 || gather2_indices[0] != 0)

  525.                 continue;

  526. 

  527.             // axis = 0

  528.             int gather3_axis = get_node_attr_i(*node3, "axis");

  529.             if (gather3_axis != 0)

  530.                 continue;

  531. 

  532.             // indices = 1

  533.             if (weights.find(node3->input(1)) == weights.end())

  534.                 continue;

  535. 

  536.             std::vector<int> gather3_indices = get_node_attr_from_input_ai(weights[node3->input(1)]);

  537.             if (gather3_indices.size() != 1 || gather3_indices[0] != 1)

  538.                 continue;

  539. 

  540.             // reduce

  541.             node2->set_op_type("noop_reducedncnn");

  542. 

  543.             node_reference[node->output(0)] -= 1;

  544. 

  545.             node_reference.erase(node_reference.find(node2->output(0)));

  546.             blob_names.erase(node2->output(0));

  547. 

  548.             node3->set_op_type("Split");

  549.             node3->clear_input();

  550.             node3->add_input(node->output(0));

  551.             node3->add_output(node3->output(0));

  552.             node3->set_output(0, node2->output(0));

  553. 

  554.             node3->clear_attribute();

  555.             onnx::AttributeProto* attr_axis = node3->add_attribute();

  556.             attr_axis->set_name("axis");

  557.             attr_axis->set_i(1);

  558. 

  559.             reduced_node_count += 1;

  560.             i += 1;

  561.         }

  562.     }

  563. }

  564. 

  565. static void fuse_hardswish(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  566. {

  567.     int node_count = mutable_graph->node_size();

  568.     for (int i = 0; i < node_count; i++)

  569.     {

  570.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  571. 

  572.         // HardSwish <= Add(+3) - Clip(0,6) - Mul(X,) - Div(/6)

  573.         // HardSwish <= Add(+3) - Clip(0,6) - Mul(X,) - Mul(*(1/6))

  574.         // HardSwish <= Add(+3) - Clip(0,6) - Mul(X,) - Constant - Div(/6)

  575.         // HardSwish <= Add(+3) - Clip(0,6) - Mul(X,) - Constant - Mul(*(1/6))

  576.         //     out = x * F.relu6(x + 3, inplace=True) / 6

  577.         if (node->op_type() == "Add")

  578.         {

  579.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  580.                 continue;

  581. 

  582.             if (i + 3 >= node_count)

  583.                 continue;

  584. 

  585.             if (binaryop_weights.find(node->input(1)) == binaryop_weights.end())

  586.                 continue;

  587. 

  588.             const onnx::TensorProto& add_three = binaryop_weights[node->input(1)];

  589.             if (add_three.dims_size() != 0 || get_tensor_proto_data_size(add_three) != 1)

  590.                 continue;

  591. 

  592.             float constant_add_three = add_three.has_raw_data() ? ((const float*)add_three.raw_data().data())[0] : add_three.float_data().data()[0];

  593.             if (constant_add_three != 3.f)

  594.                 continue;

  595. 

  596.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  597.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  598.             onnx::NodeProto* node4 = mutable_graph->mutable_node(i + 3);

  599. 

  600.             if (node4->op_type() == "Constant")

  601.             {

  602.                 if (i + 4 >= node_count)

  603.                     continue;

  604. 

  605.                 node4 = mutable_graph->mutable_node(i + 4);

  606.             }

  607. 

  608.             if (node2->op_type() != "Clip" || node3->op_type() != "Mul" || (node4->op_type() != "Div" && node4->op_type() != "Mul"))

  609.                 continue;

  610. 

  611.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  612.                 continue;

  613. 

  614.             float relu6_min;

  615.             float relu6_max;

  616.             if (node2->input_size() == 1)

  617.             {

  618.                 relu6_min = get_node_attr_f(*node2, "min", -FLT_MAX);

  619.                 relu6_max = get_node_attr_f(*node2, "max", FLT_MAX);

  620.             }

  621.             else

  622.             {

  623.                 const onnx::TensorProto& min_tp = weights[node2->input(1)];

  624.                 const onnx::TensorProto& max_tp = weights[node2->input(2)];

  625.                 const float* min_data = min_tp.has_raw_data() ? (const float*)min_tp.raw_data().data() : min_tp.float_data().data();

  626.                 const float* max_data = max_tp.has_raw_data() ? (const float*)max_tp.raw_data().data() : max_tp.float_data().data();

  627. 

  628.                 relu6_min = min_data[0];

  629.                 relu6_max = max_data[0];

  630.             }

  631.             if (relu6_min != 0.f || relu6_max != 6.f)

  632.                 continue;

  633. 

  634.             if (node_reference.find(node3->output(0)) == node_reference.end() || node_reference[node3->output(0)] != 1)

  635.                 continue;

  636. 

  637.             if (node3->input(0) != node->input(0) || node3->input(1) != node2->output(0))

  638.                 continue;

  639. 

  640.             if (binaryop_weights.find(node4->input(1)) == binaryop_weights.end())

  641.                 continue;

  642. 

  643.             const onnx::TensorProto& div_six = binaryop_weights[node4->input(1)];

  644.             if (div_six.dims_size() != 0 || get_tensor_proto_data_size(div_six) != 1)

  645.                 continue;

  646. 

  647.             float constant_div_six = div_six.has_raw_data() ? ((const float*)div_six.raw_data().data())[0] : div_six.float_data().data()[0];

  648.             if (node4->op_type() == "Div" && constant_div_six != 6.f)

  649.                 continue;

  650.             if (node4->op_type() == "Mul" && constant_div_six != 1 / 6.f)

  651.                 continue;

  652. 

  653.             // reduce

  654.             node->set_op_type("noop_reducedncnn");

  655.             node2->set_op_type("noop_reducedncnn");

  656.             node3->set_op_type("noop_reducedncnn");

  657. 

  658.             node_reference[node->input(0)] -= 1;

  659. 

  660.             node_reference.erase(node_reference.find(node->output(0)));

  661.             node_reference.erase(node_reference.find(node2->output(0)));

  662.             node_reference.erase(node_reference.find(node3->output(0)));

  663.             blob_names.erase(node->output(0));

  664.             blob_names.erase(node2->output(0));

  665.             blob_names.erase(node3->output(0));

  666. 

  667.             reduced_binaryop_weights.push_back(node->input(1));

  668.             reduced_binaryop_weights.push_back(node4->input(1));

  669. 

  670.             node4->set_op_type("HardSwish");

  671.             node4->clear_input();

  672.             node4->add_input(node->input(0));

  673. 

  674.             onnx::AttributeProto* attr_alpha = node4->add_attribute();

  675.             attr_alpha->set_name("alpha");

  676.             attr_alpha->set_f(1.f / 6.f);

  677. 

  678.             onnx::AttributeProto* attr_beta = node4->add_attribute();

  679.             attr_beta->set_name("beta");

  680.             attr_beta->set_f(3.f / 6.f);

  681. 

  682.             reduced_node_count += 3;

  683.             i += 3;

  684.         }

  685.     }

  686. 

  687.     for (int i = 0; i < node_count; i++)

  688.     {

  689.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  690. 

  691.         // HardSwish <= HardSigmoid - Mul

  692.         //     out = x * hsigmoid(x)

  693.         if (node->op_type() == "HardSigmoid")

  694.         {

  695.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  696.                 continue;

  697. 

  698.             float alpha = get_node_attr_f(*node, "alpha", 0.2f);

  699.             float beta = get_node_attr_f(*node, "beta", 0.5f);

  700. 

  701.             if (i + 1 >= node_count)

  702.                 continue;

  703. 

  704.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  705. 

  706.             if (node2->op_type() != "Mul")

  707.                 continue;

  708. 

  709.             if (node2->input(0) != node->input(0) || node2->input(1) != node->output(0))

  710.                 continue;

  711. 

  712.             // reduce

  713.             node->set_op_type("noop_reducedncnn");

  714. 

  715.             node_reference[node->input(0)] -= 1;

  716. 

  717.             node_reference.erase(node_reference.find(node->output(0)));

  718.             blob_names.erase(node->output(0));

  719. 

  720.             node2->set_op_type("HardSwish");

  721.             node2->clear_input();

  722.             node2->add_input(node->input(0));

  723. 

  724.             onnx::AttributeProto* attr_alpha = node2->add_attribute();

  725.             attr_alpha->set_name("alpha");

  726.             attr_alpha->set_f(alpha);

  727. 

  728.             onnx::AttributeProto* attr_beta = node2->add_attribute();

  729.             attr_beta->set_name("beta");

  730.             attr_beta->set_f(beta);

  731. 

  732.             reduced_node_count += 1;

  733.             i += 1;

  734.         }

  735.     }

  736. }

  737. 

  738. static void fuse_hardsigmoid(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  739. {

  740.     int node_count = mutable_graph->node_size();

  741.     for (int i = 0; i < node_count; i++)

  742.     {

  743.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  744. 

  745.         // HardSigmoid <= Add(+3) - Clip(0,6) - Div(/6)

  746.         // HardSigmoid <= Add(+3) - Clip(0,6) - Mul(*(1/6))

  747.         // HardSigmoid <= Add(+3) - Clip(0,6) - Constant - Div(/6)

  748.         // HardSigmoid <= Add(+3) - Clip(0,6) - Constant - Mul(*(1/6))

  749.         //     out = F.relu6(x + 3, inplace=True) / 6

  750.         if (node->op_type() == "Add")

  751.         {

  752.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  753.                 continue;

  754. 

  755.             if (i + 2 >= node_count)

  756.                 continue;

  757. 

  758.             if (binaryop_weights.find(node->input(1)) == binaryop_weights.end())

  759.                 continue;

  760. 

  761.             const onnx::TensorProto& add_three = binaryop_weights[node->input(1)];

  762.             if (add_three.dims_size() != 0 || get_tensor_proto_data_size(add_three) != 1)

  763.                 continue;

  764. 

  765.             float constant_add_three = add_three.has_raw_data() ? ((const float*)add_three.raw_data().data())[0] : add_three.float_data().data()[0];

  766.             if (constant_add_three != 3.f)

  767.                 continue;

  768. 

  769.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  770.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  771. 

  772.             if (node3->op_type() == "Constant")

  773.             {

  774.                 if (i + 3 >= node_count)

  775.                     continue;

  776. 

  777.                 node3 = mutable_graph->mutable_node(i + 3);

  778.             }

  779. 

  780.             if (node2->op_type() != "Clip" || (node3->op_type() != "Div" && node3->op_type() != "Mul"))

  781.                 continue;

  782. 

  783.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  784.                 continue;

  785. 

  786.             float relu6_min;

  787.             float relu6_max;

  788.             if (node2->input_size() == 1)

  789.             {

  790.                 relu6_min = get_node_attr_f(*node2, "min", -FLT_MAX);

  791.                 relu6_max = get_node_attr_f(*node2, "max", FLT_MAX);

  792.             }

  793.             else

  794.             {

  795.                 const onnx::TensorProto& min_tp = weights[node2->input(1)];

  796.                 const onnx::TensorProto& max_tp = weights[node2->input(2)];

  797.                 const float* min_data = min_tp.has_raw_data() ? (const float*)min_tp.raw_data().data() : min_tp.float_data().data();

  798.                 const float* max_data = max_tp.has_raw_data() ? (const float*)max_tp.raw_data().data() : max_tp.float_data().data();

  799. 

  800.                 relu6_min = min_data[0];

  801.                 relu6_max = max_data[0];

  802.             }

  803.             if (relu6_min != 0.f || relu6_max != 6.f)

  804.                 continue;

  805. 

  806.             if (binaryop_weights.find(node3->input(1)) == binaryop_weights.end())

  807.                 continue;

  808. 

  809.             const onnx::TensorProto& div_six = binaryop_weights[node3->input(1)];

  810.             if (div_six.dims_size() != 0 || get_tensor_proto_data_size(div_six) != 1)

  811.                 continue;

  812. 

  813.             float constant_div_six = div_six.has_raw_data() ? ((const float*)div_six.raw_data().data())[0] : div_six.float_data().data()[0];

  814.             if (node3->op_type() == "Div" && constant_div_six != 6.f)

  815.                 continue;

  816.             if (node3->op_type() == "Mul" && constant_div_six != 1 / 6.f)

  817.                 continue;

  818. 

  819.             // reduce

  820.             node->set_op_type("noop_reducedncnn");

  821.             node2->set_op_type("noop_reducedncnn");

  822. 

  823.             node_reference.erase(node_reference.find(node->output(0)));

  824.             node_reference.erase(node_reference.find(node2->output(0)));

  825.             blob_names.erase(node->output(0));

  826.             blob_names.erase(node2->output(0));

  827. 

  828.             reduced_binaryop_weights.push_back(node->input(1));

  829.             reduced_binaryop_weights.push_back(node3->input(1));

  830. 

  831.             node3->set_op_type("HardSigmoid");

  832.             node3->clear_input();

  833.             node3->add_input(node->input(0));

  834. 

  835.             onnx::AttributeProto* attr_alpha = node3->add_attribute();

  836.             attr_alpha->set_name("alpha");

  837.             attr_alpha->set_f(1.f / 6.f);

  838. 

  839.             onnx::AttributeProto* attr_beta = node3->add_attribute();

  840.             attr_beta->set_name("beta");

  841.             attr_beta->set_f(3.f / 6.f);

  842. 

  843.             reduced_node_count += 2;

  844.             i += 2;

  845.         }

  846.     }

  847. }

  848. 

  849. static void fuse_swish(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  850. {

  851.     int node_count = mutable_graph->node_size();

  852.     for (int i = 0; i < node_count; i++)

  853.     {

  854.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  855. 

  856.         // Swish <= Sigmoid - Mul

  857.         //     x * torch.sigmoid(x)

  858.         if (node->op_type() == "Sigmoid")

  859.         {

  860.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  861.                 continue;

  862. 

  863.             if (i + 1 >= node_count)

  864.                 continue;

  865. 

  866.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  867. 

  868.             if (node2->op_type() != "Mul")

  869.                 continue;

  870. 

  871.             if (node2->input(0) != node->input(0) || node2->input(1) != node->output(0))

  872.                 continue;

  873. 

  874.             // reduce

  875.             node->set_op_type("noop_reducedncnn");

  876. 

  877.             node_reference[node->input(0)] -= 1;

  878. 

  879.             node_reference.erase(node_reference.find(node->output(0)));

  880.             blob_names.erase(node->output(0));

  881. 

  882.             node2->set_op_type("Swish");

  883.             node2->clear_input();

  884.             node2->add_input(node->input(0));

  885. 

  886.             reduced_node_count += 1;

  887.             i += 1;

  888.         }

  889.     }

  890. }

  891. 

  892. static void fuse_batchnorm1d_squeeze_unsqueeze(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  893. {

  894.     int node_count = mutable_graph->node_size();

  895.     for (int i = 0; i < node_count; i++)

  896.     {

  897.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  898. 

  899.         // BatchNormalization <= Unsqueeze - BatchNormalization - Squeeze

  900.         if (node->op_type() == "Unsqueeze")

  901.         {

  902.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  903.                 continue;

  904. 

  905.             if (i + 2 >= node_count)

  906.                 continue;

  907. 

  908.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  909.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  910. 

  911.             if (node2->op_type() != "BatchNormalization" || node3->op_type() != "Squeeze")

  912.                 continue;

  913. 

  914.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  915.                 continue;

  916. 

  917.             if (node2->input(0) != node->output(0) || node3->input(0) != node2->output(0))

  918.                 continue;

  919. 

  920.             // reduce

  921.             node->set_op_type("noop_reducedncnn");

  922.             node3->set_op_type("noop_reducedncnn");

  923. 

  924.             node_reference.erase(node_reference.find(node->output(0)));

  925.             node_reference.erase(node_reference.find(node2->output(0)));

  926.             blob_names.erase(node->output(0));

  927.             blob_names.erase(node2->output(0));

  928. 

  929.             node2->set_input(0, node->input(0));

  930.             node2->set_output(0, node3->output(0));

  931. 

  932.             reduced_node_count += 2;

  933.             i += 2;

  934.         }

  935.     }

  936. }

  937. 

  938. static void fuse_unsqueeze_prelu(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  939. {

  940.     int node_count = mutable_graph->node_size();

  941.     for (int i = 0; i < node_count; i++)

  942.     {

  943.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  944. 

  945.         // PReLU <= Unsqueeze - PReLU

  946.         if (node->op_type() == "Unsqueeze")

  947.         {

  948.             // check weight

  949.             if (weights.find(node->input(0)) == weights.end())

  950.                 continue;

  951. 

  952.             onnx::TensorProto& B = weights[node->input(0)];

  953.             if (B.dims_size() != 1)

  954.                 continue;

  955. 

  956.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  957.                 continue;

  958. 

  959.             // axes = (1, 2)

  960.             std::vector<int> axes = get_node_attr_ai(*node, "axes");

  961.             if (axes.size() != 2)

  962.                 continue;

  963.             if (axes[0] != 1 || axes[1] != 2)

  964.                 continue;

  965. 

  966.             if (i + 1 >= node_count)

  967.                 continue;

  968. 

  969.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  970. 

  971.             if (node2->op_type() != "PRelu")

  972.                 continue;

  973. 

  974.             if (node2->input(1) != node->output(0))

  975.                 continue;

  976. 

  977.             // reduce

  978.             node->set_op_type("noop_reducedncnn");

  979. 

  980.             node_reference.erase(node_reference.find(node->output(0)));

  981.             blob_names.erase(node->output(0));

  982. 

  983.             node2->set_input(1, node->input(0));

  984. 

  985.             reduced_node_count += 1;

  986.             i += 1;

  987.         }

  988.     }

  989. }

  990. 

  991. static void fuse_normalize(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  992. {

  993.     int node_count = mutable_graph->node_size();

  994.     for (int i = 0; i < node_count; i++)

  995.     {

  996.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  997. 

  998.         // Normalize <= X - ReduceL2 - Clip - Expand - Div

  999.         // Normalize <= X - ReduceL2 - Clip - Shape - Expand - Div

  1000.         if (node->op_type() == "ReduceL2")

  1001.         {

  1002.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  1003.                 continue;

  1004. 

  1005.             // axes = (1)

  1006.             std::vector<int> axes = get_node_attr_ai(*node, "axes");

  1007.             if (axes.size() != 1)

  1008.                 continue;

  1009.             if (axes[0] != 1)

  1010.                 continue;

  1011. 

  1012.             if (i + 3 >= node_count)

  1013.                 continue;

  1014. 

  1015.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  1016.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  1017.             onnx::NodeProto* node4 = mutable_graph->mutable_node(i + 3);

  1018. 

  1019.             bool has_shape_node = node3->op_type() == "Shape";

  1020.             onnx::NodeProto* node_shape = 0;

  1021.             if (has_shape_node)

  1022.             {

  1023.                 if (i + 4 >= node_count)

  1024.                     continue;

  1025. 

  1026.                 node_shape = node3;

  1027.                 node3 = mutable_graph->mutable_node(i + 3);

  1028.                 node4 = mutable_graph->mutable_node(i + 4);

  1029.             }

  1030. 

  1031.             if (node2->op_type() != "Clip" || node3->op_type() != "Expand" || node4->op_type() != "Div")

  1032.                 continue;

  1033. 

  1034.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  1035.                 continue;

  1036. 

  1037.             if (node_reference.find(node3->output(0)) == node_reference.end() || node_reference[node3->output(0)] != 1)

  1038.                 continue;

  1039. 

  1040.             if (node2->input(0) != node->output(0) || node3->input(0) != node2->output(0)

  1041.                     || node4->input(0) != node->input(0) || node4->input(1) != node3->output(0))

  1042.                 continue;

  1043. 

  1044.             if (has_shape_node)

  1045.             {

  1046.                 if (node_shape->input(0) != node->input(0) || node3->input(1) != node_shape->output(0))

  1047.                     continue;

  1048.             }

  1049. 

  1050.             // +eps

  1051.             float clip_min;

  1052.             if (node2->input_size() == 1)

  1053.             {

  1054.                 clip_min = get_node_attr_f(*node2, "min", -FLT_MAX);

  1055.             }

  1056.             else

  1057.             {

  1058.                 const onnx::TensorProto& min_tp = weights[node2->input(1)];

  1059.                 const float* min_data = min_tp.has_raw_data() ? (const float*)min_tp.raw_data().data() : min_tp.float_data().data();

  1060. 

  1061.                 clip_min = min_data[0];

  1062.             }

  1063. 

  1064.             // reduce

  1065.             node->set_op_type("noop_reducedncnn");

  1066.             node2->set_op_type("noop_reducedncnn");

  1067.             if (has_shape_node)

  1068.             {

  1069.                 node_shape->set_op_type("noop_reducedncnn");

  1070.             }

  1071.             node3->set_op_type("noop_reducedncnn");

  1072. 

  1073.             node_reference[node->input(0)] -= has_shape_node ? 2 : 1;

  1074. 

  1075.             node_reference.erase(node_reference.find(node->output(0)));

  1076.             node_reference.erase(node_reference.find(node2->output(0)));

  1077.             if (has_shape_node)

  1078.             {

  1079.                 node_reference.erase(node_reference.find(node_shape->output(0)));

  1080.             }

  1081.             node_reference.erase(node_reference.find(node3->output(0)));

  1082.             blob_names.erase(node->output(0));

  1083.             blob_names.erase(node2->output(0));

  1084.             if (has_shape_node)

  1085.             {

  1086.                 blob_names.erase(node_shape->output(0));

  1087.             }

  1088.             blob_names.erase(node3->output(0));

  1089. 

  1090.             node4->set_op_type("Normalize");

  1091.             node4->clear_input();

  1092.             node4->add_input(node->input(0));

  1093. 

  1094.             onnx::AttributeProto* attr_alpha = node4->add_attribute();

  1095.             attr_alpha->set_name("eps");

  1096.             attr_alpha->set_f(clip_min);

  1097. 

  1098.             reduced_node_count += has_shape_node ? 4 : 3;

  1099.             i += has_shape_node ? 4 : 3;

  1100.         }

  1101.     }

  1102. }

  1103. 

  1104. static void fuse_flatten(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  1105. {

  1106.     int node_count = mutable_graph->node_size();

  1107.     for (int i = 0; i < node_count; i++)

  1108.     {

  1109.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  1110. 

  1111.         // Flatten <= X - Shape - Gather - Constant - Unsqueeze - Unsqueeze - Concat - Reshape

  1112.         if (node->op_type() == "Shape")

  1113.         {

  1114.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  1115.                 continue;

  1116. 

  1117.             if (i + 6 >= node_count)

  1118.                 continue;

  1119. 

  1120.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  1121.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  1122.             onnx::NodeProto* node4 = mutable_graph->mutable_node(i + 3);

  1123.             onnx::NodeProto* node5 = mutable_graph->mutable_node(i + 4);

  1124.             onnx::NodeProto* node6 = mutable_graph->mutable_node(i + 5);

  1125.             onnx::NodeProto* node7 = mutable_graph->mutable_node(i + 6);

  1126. 

  1127.             if (node2->op_type() != "Gather" || node3->op_type() != "Constant" || node4->op_type() != "Unsqueeze" || node5->op_type() != "Unsqueeze"

  1128.                     || node6->op_type() != "Concat" || node7->op_type() != "Reshape")

  1129.                 continue;

  1130. 

  1131.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  1132.                 continue;

  1133. 

  1134.             //             if (node_reference.find(node3->output(0)) == node_reference.end() || node_reference[node3->output(0)] != 1)

  1135.             //                 continue;

  1136. 

  1137.             if (node_reference.find(node4->output(0)) == node_reference.end() || node_reference[node4->output(0)] != 1)

  1138.                 continue;

  1139. 

  1140.             if (node_reference.find(node5->output(0)) == node_reference.end() || node_reference[node5->output(0)] != 1)

  1141.                 continue;

  1142. 

  1143.             if (node_reference.find(node6->output(0)) == node_reference.end() || node_reference[node6->output(0)] != 1)

  1144.                 continue;

  1145. 

  1146.             if (node2->input(0) != node->output(0) || node4->input(0) != node2->output(0) || node5->input(0) != node3->output(0)

  1147.                     || node6->input(0) != node4->output(0) || node6->input(1) != node5->output(0)

  1148.                     || node7->input(0) != node->input(0) || node7->input(1) != node6->output(0))

  1149.                 continue;

  1150. 

  1151.             // axis = 0

  1152.             int gather_axis = get_node_attr_i(*node2, "axis");

  1153.             if (gather_axis != 0)

  1154.                 continue;

  1155. 

  1156.             // indices = 0

  1157.             if (weights.find(node2->input(1)) == weights.end())

  1158.                 continue;

  1159. 

  1160.             std::vector<int> gather_indices = get_node_attr_from_input_ai(weights[node2->input(1)]);

  1161.             if (gather_indices.size() != 1 || gather_indices[0] != 0)

  1162.                 continue;

  1163. 

  1164.             // axes = (0)

  1165.             std::vector<int> unsqueeze_axes = get_node_attr_ai(*node4, "axes");

  1166.             if (unsqueeze_axes.size() != 1)

  1167.                 continue;

  1168.             if (unsqueeze_axes[0] != 0)

  1169.                 continue;

  1170. 

  1171.             // axes = (0)

  1172.             std::vector<int> unsqueeze2_axes = get_node_attr_ai(*node5, "axes");

  1173.             if (unsqueeze2_axes.size() != 1)

  1174.                 continue;

  1175.             if (unsqueeze2_axes[0] != 0)

  1176.                 continue;

  1177. 

  1178.             // data = -1

  1179.             if (weights.find(node5->input(0)) == weights.end())

  1180.                 continue;

  1181. 

  1182.             std::vector<int> unsqueeze2_data = get_node_attr_from_input_ai(weights[node5->input(0)]);

  1183.             if (unsqueeze2_data.size() != 1 || unsqueeze2_data[0] != -1)

  1184.                 continue;

  1185. 

  1186.             // axis = 0

  1187.             int concat_axis = get_node_attr_i(*node6, "axis");

  1188.             if (concat_axis != 0)

  1189.                 continue;

  1190. 

  1191.             // reduce

  1192.             node->set_op_type("noop_reducedncnn");

  1193.             node2->set_op_type("noop_reducedncnn");

  1194.             //             node3->set_op_type("noop_reducedncnn");

  1195.             node4->set_op_type("noop_reducedncnn");

  1196.             node5->set_op_type("noop_reducedncnn");

  1197.             node6->set_op_type("noop_reducedncnn");

  1198. 

  1199.             node_reference[node->input(0)] -= 1;

  1200. 

  1201.             node_reference.erase(node_reference.find(node->output(0)));

  1202.             node_reference.erase(node_reference.find(node2->output(0)));

  1203.             //             node_reference.erase(node_reference.find(node3->output(0)));

  1204.             node_reference.erase(node_reference.find(node4->output(0)));

  1205.             node_reference.erase(node_reference.find(node5->output(0)));

  1206.             node_reference.erase(node_reference.find(node6->output(0)));

  1207.             blob_names.erase(node->output(0));

  1208.             blob_names.erase(node2->output(0));

  1209.             //             blob_names.erase(node3->output(0));

  1210.             blob_names.erase(node4->output(0));

  1211.             blob_names.erase(node5->output(0));

  1212.             blob_names.erase(node6->output(0));

  1213. 

  1214.             node7->set_op_type("Flatten");

  1215.             node7->clear_input();

  1216.             node7->add_input(node->input(0));

  1217. 

  1218.             reduced_node_count += 5;

  1219.             i += 5;

  1220.         }

  1221.     }

  1222. }

  1223. 

  1224. static void fuse_pixelshuffle(onnx::GraphProto* mutable_graph, std::map<std::string, onnx::TensorProto>& weights, std::map<std::string, onnx::TensorProto>& binaryop_weights, std::map<std::string, int>& node_reference, std::set<std::string>& blob_names, int& reduced_node_count, std::vector<std::string>& reduced_binaryop_weights)

  1225. {

  1226.     int node_count = mutable_graph->node_size();

  1227.     for (int i = 0; i < node_count; i++)

  1228.     {

  1229.         onnx::NodeProto* node = mutable_graph->mutable_node(i);

  1230. 

  1231.         // PixelShuffle <= Reshape - Transpose - Reshape

  1232.         // PixelShuffle <= Reshape - Transpose - Constant - Reshape

  1233.         if (node->op_type() == "Reshape")

  1234.         {

  1235.             if (node_reference.find(node->output(0)) == node_reference.end() || node_reference[node->output(0)] != 1)

  1236.                 continue;

  1237. 

  1238.             std::vector<int> shape;

  1239.             if (node->input_size() == 1)

  1240.             {

  1241.                 shape = get_node_attr_ai(*node, "shape");

  1242.             }

  1243.             else

  1244.             {

  1245.                 // skip weight reshape

  1246.                 if (weights.find(node->input(1)) == weights.end())

  1247.                     continue;

  1248. 

  1249.                 shape = get_node_attr_from_input_ai(weights[node->input(1)]);

  1250.             }

  1251. 

  1252.             // -1, 3, upscale_factor, upscale_factor, height, width

  1253.             if (shape.size() != 6)

  1254.                 continue;

  1255. 

  1256.             if (shape[0] != 1 && shape[0] != -1)

  1257.                 continue;

  1258. 

  1259.             if (shape[2] != shape[3])

  1260.                 continue;

  1261. 

  1262.             if (i + 2 >= node_count)

  1263.                 continue;

  1264. 

  1265.             onnx::NodeProto* node2 = mutable_graph->mutable_node(i + 1);

  1266.             onnx::NodeProto* node3 = mutable_graph->mutable_node(i + 2);

  1267. 

  1268.             if (node3->op_type() == "Constant")

  1269.             {

  1270.                 if (i + 3 >= node_count)

  1271.                     continue;

  1272. 

  1273.                 node3 = mutable_graph->mutable_node(i + 3);

  1274.             }

  1275. 

  1276.             if (node2->op_type() != "Transpose" || node3->op_type() != "Reshape")

  1277.                 continue;

  1278. 

  1279.             if (node_reference.find(node2->output(0)) == node_reference.end() || node_reference[node2->output(0)] != 1)

  1280.                 continue;

  1281. 

  1282.             // 0 1 4 2 5 3

  1283.             std::vector<int> perm = get_node_attr_ai(*node2, "perm");

  1284.             if (perm.size() != 6)

  1285.                 continue;

  1286. 

  1287.             if (perm[0] != 0 || perm[1] != 1 || perm[2] != 4 || perm[3] != 2 || perm[4] != 5 || perm[5] != 3)

  1288.                 continue;

  1289. 

  1290.             std::vector<int> shape3;

  1291.             if (node3->input_size() == 1)

  1292.             {

  1293.                 shape3 = get_node_attr_ai(*node3, "shape");

  1294.             }

  1295.             else

  1296.             {

  1297.                 // skip weight reshape

  1298.                 if (weights.find(node3->input(1)) == weights.end())

  1299.                     continue;

  1300. 

  1301.                 shape3 = get_node_attr_from_input_ai(weights[node3->input(1)]);

  1302.             }

  1303. 

  1304.             // -1, 3, height, width

  1305.             if (shape3.size() != 4)

  1306.                 continue;

  1307. 

  1308.             if (shape3[0] != 1 && shape3[0] != -1)

  1309.                 continue;

  1310. 

  1311.             if (shape3[1] != shape[1] && shape3[2] != shape[2] * shape[4] && shape3[3] != shape[3] * shape[5])

  1312.                 continue;

  1313. 

  1314.             // reduce

  1315.             node->set_op_type("noop_reducedncnn");

  1316.             node2->set_op_type("noop_reducedncnn");

  1317. 

  1318.             node_reference.erase(node_reference.find(node->output(0)));

  1319.             node_reference.erase(node_reference.find(node2->output(0)));

  1320.             blob_names.erase(node->output(0));

  1321.             blob_names.erase(node2->output(0));

  1322. 

  1323.             node3->set_op_type("PixelShuffle");

  1324.             node3->set_input(0, node->input(0));

  1325. 

  1326.             onnx::AttributeProto* attr_group = node3->add_attribute();

  1327.             attr_group->set_name("scale_factor");

  1328.             attr_group->set_i(shape[2]);

  1329. 

  1330.             reduced_node_count += 2;

  1331.             i += 2;

  1332.         }

  1333.     }

  1334. }

  1335. 

  1336. int main(int argc, char** argv)

  1337. {

  1338.     const char* onnxpb = argv[1];

  1339.     const char* ncnn_prototxt = argc >= 4 ? argv[2] : "ncnn.param";

  1340.     const char* ncnn_modelbin = argc >= 4 ? argv[3] : "ncnn.bin";

  1341. 

  1342.     onnx::ModelProto model;

  1343. 

  1344.     // load

  1345.     bool s1 = read_proto_from_binary(onnxpb, &model);

  1346.     if (!s1)

  1347.     {

  1348.         fprintf(stderr, "read_proto_from_binary failed\n");

  1349.         return -1;

  1350.     }

  1351. 

  1352.     FILE* pp = fopen(ncnn_prototxt, "wb");

  1353.     FILE* bp = fopen(ncnn_modelbin, "wb");

  1354. 

  1355.     // magic

  1356.     fprintf(pp, "7767517\n");

  1357. 

  1358.     const onnx::GraphProto& graph = model.graph();

  1359.     onnx::GraphProto* mutable_graph = model.mutable_graph();

  1360. 

  1361.     int node_count = graph.node_size();

  1362. 

  1363.     // node reference

  1364.     std::map<std::string, int> node_reference;

  1365. 

  1366.     // weight node and weight reshape node

  1367.     std::map<std::string, onnx::TensorProto> weights;

  1368. 

  1369.     // weight node before BinaryOp

  1370.     std::map<std::string, onnx::TensorProto> binaryop_weights;

  1371. 

  1372.     for (int j = 0; j < graph.initializer_size(); j++)

  1373.     {

  1374.         const onnx::TensorProto& initializer = graph.initializer(j);

  1375. 

  1376.         //         fprintf(stderr, "weight = %s\n", initializer.name().c_str());

  1377. 

  1378.         weights[initializer.name()] = initializer;

  1379.     }

  1380. 

  1381.     // global definition line

  1382.     // [layer count] [blob count]

  1383.     std::set<std::string> blob_names;

  1384.     for (int i = 0; i < node_count; i++)

  1385.     {

  1386.         const onnx::NodeProto& node = graph.node(i);

  1387. 

  1388.         const std::string& op = node.op_type();

  1389. 

  1390.         std::string name = node.name();

  1391.         if (name.empty())

  1392.         {

  1393.             name = node.output(0);

  1394.         }

  1395. 

  1396.         if (op == "Constant")

  1397.         {

  1398.             onnx::TensorProto tensor = get_node_attr_tensor(node, "value");

  1399.             weights[node.output(0)] = tensor;

  1400.             continue;

  1401.         }

  1402.         else if (op == "Reshape")

  1403.         {

  1404.             if (node.input_size() == 1)

  1405.             {

  1406.                 const std::string& input_name = node.input(0);

  1407. 

  1408.                 // check weight

  1409.                 if (weights.find(input_name) != weights.end())

  1410.                 {

  1411.                     weights[node.output(0)] = weights[input_name];

  1412.                     continue;

  1413.                 }

  1414.             }

  1415.             else if (node.input_size() == 2)

  1416.             {

  1417.                 // opset 5

  1418.                 const std::string& input_name = node.input(0);

  1419. 

  1420.                 // check weight

  1421.                 if (weights.find(input_name) != weights.end())

  1422.                 {

  1423.                     weights[node.output(0)] = weights[input_name];

  1424. 

  1425.                     // set weight shape directly

  1426.                     const onnx::TensorProto& shape_tp = weights[node.input(1)];

  1427.                     const int64_t* shape_data = shape_tp.int64_data().data();

  1428. 

  1429.                     weights[node.output(0)].clear_dims();

  1430.                     for (int j = 0; j < shape_tp.int64_data_size(); j++)

  1431.                     {

  1432.                         weights[node.output(0)].add_dims(shape_data[j]);

  1433.                     }

  1434. 

  1435.                     continue;

  1436.                 }

  1437.             }

  1438.         }

  1439.         else

  1440.         {

  1441.             bool isBinaryOp = false;

  1442.             if (op == "Add" || op == "Sub" || op == "Mul" || op == "Div")

  1443.             {

  1444.                 isBinaryOp = true;

  1445.             }

  1446. 

  1447.             if (isBinaryOp)

  1448.             {

  1449.                 // check weights

  1450.                 for (int j = 0; j < node.input_size(); j++)

  1451.                 {

  1452.                     const std::string& input_name = node.input(j);

  1453. 

  1454.                     std::map<std::string, onnx::TensorProto>::iterator it = weights.find(input_name);

  1455.                     if (it != weights.end())

  1456.                     {

  1457.                         // binary op with weight, insert MemoryData layer and const blob

  1458.                         binaryop_weights[input_name] = it->second;

  1459.                         weights.erase(it);

  1460.                     }

  1461.                 }

  1462.             }

  1463.         }

  1464. 

  1465.         for (int j = 0; j < (int)node.input_size(); j++)

  1466.         {

  1467.             const std::string& input_name = node.input(j);

  1468. 

  1469.             // check weight

  1470.             if (weights.find(input_name) != weights.end())

  1471.             {

  1472.                 continue;

  1473.             }

  1474. 

  1475.             blob_names.insert(input_name);

  1476. 

  1477.             if (node_reference.find(input_name) == node_reference.end())

  1478.             {

  1479.                 node_reference[input_name] = 1;

  1480.             }

  1481.             else

  1482.             {

  1483.                 node_reference[input_name] = node_reference[input_name] + 1;

  1484.             }

  1485. 

  1486.             if (op == "LSTM")

  1487.             {

  1488.                 // ignore all optional input blobs

  1489.                 break;

  1490.             }

  1491.         }

  1492. 

  1493.         if (op == "Dropout")

  1494.         {

  1495.             const std::string& output_name = node.output(0);

  1496.             blob_names.insert(output_name);

  1497.             continue;

  1498.         }

  1499. 

  1500.         if (op == "LSTM")

  1501.         {

  1502.             const std::string& output_name = node.output(0);

  1503.             blob_names.insert(output_name);

  1504.             continue;

  1505.         }

  1506. 

  1507.         for (int j = 0; j < (int)node.output_size(); j++)

  1508.         {

  1509.             const std::string& output_name = node.output(j);

  1510. 

  1511.             blob_names.insert(output_name);

  1512.         }

  1513.     }

  1514. 

  1515.     // include Input node

  1516.     int input_node_count = 0;

  1517.     for (int j = 0; j < graph.input_size(); j++)

  1518.     {

  1519.         const std::string& input_name = graph.input(j).name();

  1520. 

  1521.         // check weight

  1522.         if (weights.find(input_name) != weights.end())

  1523.             continue;

  1524. 

  1525.         // check weight before BinaryOp

  1526.         if (binaryop_weights.find(input_name) != binaryop_weights.end())

  1527.             continue;

  1528. 

  1529.         blob_names.insert(input_name);

  1530. 

  1531.         input_node_count++;

  1532.     }

  1533. 

  1534.     // op chain fusion

  1535.     int reduced_node_count = 0;

  1536.     std::vector<std::string> reduced_binaryop_weights;

  1537.     fuse_matmul(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1538.     fuse_shufflechannel(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1539.     fuse_shufflechannel_split(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1540.     fuse_hardsigmoid(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1541.     fuse_hardswish(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1542.     fuse_swish(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1543.     fuse_batchnorm1d_squeeze_unsqueeze(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1544.     fuse_unsqueeze_prelu(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1545.     fuse_normalize(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1546.     fuse_flatten(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1547.     fuse_pixelshuffle(mutable_graph, weights, binaryop_weights, node_reference, blob_names, reduced_node_count, reduced_binaryop_weights);

  1548. 

  1549.     // remove node_reference entry with reference equals to one

  1550.     int splitncnn_blob_count = 0;

  1551.     std::map<std::string, int>::iterator it = node_reference.begin();

  1552.     while (it != node_reference.end())

  1553.     {

  1554.         if (it->second == 1)

  1555.         {

  1556.             node_reference.erase(it++);

  1557.         }

  1558.         else

  1559.         {

  1560.             splitncnn_blob_count += it->second;

  1561.             //             fprintf(stderr, "%s %d\n", it->first.c_str(), it->second);

  1562.             ++it;

  1563.         }

  1564.     }

  1565. 

  1566.     fprintf(pp, "%lu %lu\n", node_count - reduced_node_count + input_node_count + node_reference.size() + graph.initializer_size() - weights.size() - reduced_binaryop_weights.size(), blob_names.size() - reduced_binaryop_weights.size() + splitncnn_blob_count);

  1567. 

  1568.     int internal_split = 0;

  1569. 

  1570.     // place Input at the beginning

  1571.     for (int j = 0; j < graph.input_size(); j++)

  1572.     {

  1573.         const std::string& input_name = graph.input(j).name();

  1574. 

  1575.         // check weight

  1576.         if (weights.find(input_name) != weights.end())

  1577.             continue;

  1578. 

  1579.         // check weight before BinaryOp

  1580.         if (binaryop_weights.find(input_name) != binaryop_weights.end())

  1581.             continue;

  1582. 

  1583.         fprintf(pp, "%-16s %-24s 0 1 %s\n", "Input", input_name.c_str(), input_name.c_str());

  1584. 

  1585.         // split the input

  1586.         if (node_reference.find(input_name) == node_reference.end())

  1587.         {

  1588.             continue;

  1589.         }

  1590. 

  1591.         int refcount = node_reference[input_name];

  1592.         if (refcount <= 1)

  1593.         {

  1594.             continue;

  1595.         }

  1596. 

  1597.         char splitname[256];

  1598.         sprintf(splitname, "splitncnn_input%d", j);

  1599.         fprintf(pp, "%-16s %-24s %d %d", "Split", splitname, 1, refcount);

  1600.         fprintf(pp, " %s", input_name.c_str());

  1601. 

  1602.         for (int k = 0; k < refcount; k++)

  1603.         {

  1604.             fprintf(pp, " %s_splitncnn_%d", input_name.c_str(), k);

  1605.         }

  1606.         fprintf(pp, "\n");

  1607.     }

  1608. 

  1609.     // place MemoryData next

  1610.     for (std::map<std::string, onnx::TensorProto>::iterator it = binaryop_weights.begin(); it != binaryop_weights.end(); it++)

  1611.     {

  1612.         const std::string& input_name = it->first;

  1613. 

  1614.         if (std::find(reduced_binaryop_weights.begin(), reduced_binaryop_weights.end(), input_name) != reduced_binaryop_weights.end())

  1615.             continue;

  1616. 

  1617.         fprintf(pp, "%-16s %-24s 0 1 %s", "MemoryData", input_name.c_str(), input_name.c_str());

  1618. 

  1619.         const onnx::TensorProto& M = binaryop_weights[input_name];

  1620. 

  1621.         if (M.dims_size() == 0)

  1622.         {

  1623.             fprintf(pp, " 0=%d", get_tensor_proto_data_size(M));

  1624.         }

  1625.         else if (M.dims_size() == 1)

  1626.         {

  1627.             fprintf(pp, " 0=%d", (int)M.dims(0));

  1628.         }

  1629.         else if (M.dims_size() == 2)

  1630.         {

  1631.             fprintf(pp, " 0=%d", (int)M.dims(1));

  1632.         }

  1633.         else if (M.dims_size() == 3)

  1634.         {

  1635.             fprintf(pp, " 0=%d", (int)M.dims(2));

  1636.             fprintf(pp, " 1=%d", (int)M.dims(1));

  1637.         }

  1638.         else if (M.dims_size() == 4)

  1639.         {

  1640.             fprintf(pp, " 0=%d", (int)M.dims(3));

  1641.             fprintf(pp, " 1=%d", (int)M.dims(2));

  1642.             fprintf(pp, " 2=%d", (int)M.dims(1));

  1643.         }

  1644. 

  1645.         fprintf(pp, "\n");

  1646. 

  1647.         fwrite_tensor_proto_data(M, bp);

  1648. 

  1649.         // split the input

  1650.         if (node_reference.find(input_name) == node_reference.end())

  1651.         {

  1652.             continue;

  1653.         }

  1654. 

  1655.         int refcount = node_reference[input_name];

  1656.         if (refcount <= 1)

  1657.         {

  1658.             continue;

  1659.         }

  1660. 

  1661.         char splitname[256];

  1662.         sprintf(splitname, "splitncnn_%d", internal_split);

  1663.         fprintf(pp, "%-16s %-24s %d %d", "Split", splitname, 1, refcount);

  1664. 

  1665.         fprintf(pp, " %s", input_name.c_str());

  1666. 

  1667.         for (int k = 0; k < refcount; k++)

  1668.         {

  1669.             fprintf(pp, " %s_splitncnn_%d", input_name.c_str(), k);

  1670.         }

  1671.         fprintf(pp, "\n");

  1672. 

  1673.         internal_split++;

  1674.     }

  1675. 

  1676.     for (int i = 0; i < node_count; i++)

  1677.     {

  1678.         const onnx::NodeProto& node = graph.node(i);

  1679. 

  1680.         const std::string& op = node.op_type();

  1681. 

  1682.         //         fprintf(stderr, "op = %s\n", op.c_str());

  1683. 

  1684.         if (op == "noop_reducedncnn")

  1685.         {

  1686.             continue;

  1687.         }

  1688. 

  1689.         std::string name = node.name();

  1690.         if (name.empty())

  1691.         {

  1692.             name = node.output(0);

  1693.         }

  1694. 

  1695.         int input_size = node.input_size();

  1696.         int output_size = node.output_size();

  1697. 

  1698.         for (int j = 0; j < (int)node.input_size(); j++)

  1699.         {

  1700.             const std::string& input_name = node.input(j);

  1701. 

  1702.             // check weight

  1703.             if (weights.find(input_name) != weights.end())

  1704.             {

  1705.                 input_size--;

  1706.             }

  1707. 

  1708.             //             fprintf(stderr, "  input = %s\n", input_name.c_str());

  1709.         }

  1710.         /*

  1711.         for (int j=0; j<(int)node.output_size(); j++)

  1712.         {

  1713.             const std::string& output_name = node.output(j);

  1714.             fprintf(stderr, "  output = %s\n", output_name.c_str());

  1715.         }

  1716.         */

  1717. 

  1718.         if (op == "Abs")

  1719.         {

  1720.             fprintf(pp, "%-16s", "UnaryOp");

  1721.         }

  1722.         else if (op == "Acos")

  1723.         {

  1724.             fprintf(pp, "%-16s", "UnaryOp");

  1725.         }

  1726.         else if (op == "Add")

  1727.         {

  1728.             fprintf(pp, "%-16s", "BinaryOp");

  1729.         }

  1730.         else if (op == "Asin")

  1731.         {

  1732.             fprintf(pp, "%-16s", "UnaryOp");

  1733.         }

  1734.         else if (op == "Atan")

  1735.         {

  1736.             fprintf(pp, "%-16s", "UnaryOp");

  1737.         }

  1738.         else if (op == "AveragePool" || op == "MaxPool")

  1739.         {

  1740.             fprintf(pp, "%-16s", "Pooling");

  1741.         }

  1742.         else if (op == "BatchNormalization")

  1743.         {

  1744.             fprintf(pp, "%-16s", "BatchNorm");

  1745.         }

  1746.         else if (op == "Ceil")

  1747.         {

  1748.             fprintf(pp, "%-16s", "UnaryOp");

  1749.         }

  1750.         else if (op == "Clip")

  1751.         {

  1752.             fprintf(pp, "%-16s", "Clip");

  1753.         }

  1754.         else if (op == "Concat")

  1755.         {

  1756.             fprintf(pp, "%-16s", "Concat");

  1757.         }

  1758.         else if (op == "Constant")

  1759.         {

  1760.             // check weight before BinaryOp

  1761.             if (binaryop_weights.find(node.output(0)) != binaryop_weights.end())

  1762.             {

  1763.                 if (std::find(reduced_binaryop_weights.begin(), reduced_binaryop_weights.end(), node.output(0)) != reduced_binaryop_weights.end())

  1764.                     continue;

  1765. 

  1766.                 fprintf(pp, "%-16s", "MemoryData");

  1767.             }

  1768.             else

  1769.             {

  1770.                 continue;

  1771.             }

  1772.         }

  1773.         else if (op == "Conv")

  1774.         {

  1775.             int group = get_node_attr_i(node, "group", 1);

  1776.             if (group > 1)

  1777.             {

  1778.                 fprintf(pp, "%-16s", "ConvolutionDepthWise");

  1779.             }

  1780.             else

  1781.             {

  1782.                 fprintf(pp, "%-16s", "Convolution");

  1783.             }

  1784.         }

  1785.         else if (op == "ConvTranspose")

  1786.         {

  1787.             int group = get_node_attr_i(node, "group", 1);

  1788.             if (group > 1)

  1789.             {

  1790.                 fprintf(pp, "%-16s", "DeconvolutionDepthWise");

  1791.             }

  1792.             else

  1793.             {

  1794.                 fprintf(pp, "%-16s", "Deconvolution");

  1795.             }

  1796.         }

  1797.         else if (op == "Cos")

  1798.         {

  1799.             fprintf(pp, "%-16s", "UnaryOp");

  1800.         }

  1801.         else if (op == "DepthToSpace")

  1802.         {

  1803.             fprintf(pp, "%-16s", "PixelShuffle");

  1804.         }

  1805.         else if (op == "Div")

  1806.         {

  1807.             fprintf(pp, "%-16s", "BinaryOp");

  1808.         }

  1809.         else if (op == "Dropout")

  1810.         {

  1811.             fprintf(pp, "%-16s", "Dropout");

  1812.             output_size = 1;

  1813.         }

  1814.         else if (op == "Elu")

  1815.         {

  1816.             fprintf(pp, "%-16s", "ELU");

  1817.         }

  1818.         else if (op == "Exp")

  1819.         {

  1820.             fprintf(pp, "%-16s", "UnaryOp");

  1821.         }

  1822.         else if (op == "Flatten")

  1823.         {

  1824.             fprintf(pp, "%-16s", "Flatten");

  1825.         }

  1826.         else if (op == "Floor")

  1827.         {

  1828.             fprintf(pp, "%-16s", "UnaryOp");

  1829.         }

  1830.         else if (op == "Gemm")

  1831.         {

  1832.             float alpha = get_node_attr_f(node, "alpha", 1.f);

  1833.             float beta = get_node_attr_f(node, "beta", 1.f);

  1834.             int transA = get_node_attr_i(node, "transA", 0);

  1835.             int transB = get_node_attr_i(node, "transB", 0);

  1836. 

  1837.             if (alpha == 1.f && beta == 1.f)

  1838.             {

  1839.                 // InnerProduct-like A * B + C

  1840.                 if (transA == 0 && transB == 1)

  1841.                 {

  1842.                     fprintf(pp, "%-16s", "InnerProduct");

  1843.                 }

  1844.             }

  1845. 

  1846.             // TODO

  1847.         }

  1848.         else if (op == "GlobalAveragePool")

  1849.         {

  1850.             fprintf(pp, "%-16s", "Pooling");

  1851.         }

  1852.         else if (op == "GlobalMaxPool")

  1853.         {

  1854.             fprintf(pp, "%-16s", "Pooling");

  1855.         }

  1856.         else if (op == "HardSigmoid")

  1857.         {

  1858.             fprintf(pp, "%-16s", "HardSigmoid");

  1859.         }

  1860.         else if (op == "HardSwish")

  1861.         {

  1862.             fprintf(pp, "%-16s", "HardSwish");

  1863.         }

  1864.         else if (op == "ImageScaler")

  1865.         {

  1866.             fprintf(pp, "%-16s", "Scale");

  1867.         }

  1868.         else if (op == "InstanceNormalization")

  1869.         {

  1870.             fprintf(pp, "%-16s", "InstanceNorm");

  1871.         }

  1872.         else if (op == "LeakyRelu")

  1873.         {

  1874.             fprintf(pp, "%-16s", "ReLU");

  1875.         }

  1876.         else if (op == "Log")

  1877.         {

  1878.             fprintf(pp, "%-16s", "UnaryOp");

  1879.         }

  1880.         else if (op == "LRN")

  1881.         {

  1882.             fprintf(pp, "%-16s", "LRN");

  1883.         }

  1884.         else if (op == "LSTM")

  1885.         {

  1886.             fprintf(pp, "%-16s", "LSTM");

  1887.             // force no output hidden and cell blob

  1888.             input_size = 1;

  1889.             output_size = 1;

  1890.         }

  1891.         else if (op == "MatMul")

  1892.         {

  1893.             fprintf(pp, "%-16s", "InnerProduct");

  1894.         }

  1895.         else if (op == "Max")

  1896.         {

  1897.             fprintf(pp, "%-16s", "BinaryOp");

  1898.         }

  1899.         else if (op == "Min")

  1900.         {

  1901.             fprintf(pp, "%-16s", "BinaryOp");

  1902.         }

  1903.         else if (op == "Mul")

  1904.         {

  1905.             fprintf(pp, "%-16s", "BinaryOp");

  1906.         }

  1907.         else if (op == "Neg")

  1908.         {

  1909.             fprintf(pp, "%-16s", "UnaryOp");

  1910.         }

  1911.         else if (op == "Normalize")

  1912.         {

  1913.             fprintf(pp, "%-16s", "Normalize");

  1914.         }

  1915.         else if (op == "Pad")

  1916.         {

  1917.             fprintf(pp, "%-16s", "Padding");

  1918.         }

  1919.         else if (op == "PixelShuffle")

  1920.         {

  1921.             fprintf(pp, "%-16s", "PixelShuffle");

  1922.         }

  1923.         else if (op == "Pow")

  1924.         {

  1925.             fprintf(pp, "%-16s", "BinaryOp");

  1926.         }

  1927.         else if (op == "PRelu")

  1928.         {

  1929.             fprintf(pp, "%-16s", "PReLU");

  1930.         }

  1931.         else if (op == "Reciprocal")

  1932.         {

  1933.             fprintf(pp, "%-16s", "UnaryOp");

  1934.         }

  1935.         else if (op == "ReduceMax" || op == "ReduceMin" || op == "ReduceMean" || op == "ReduceProd" || op == "ReduceSum" || op == "ReduceSumSquare" || op == "ReduceL1" || op == "ReduceL2" || op == "ReduceLogSum" || op == "ReduceLogSumExp")

  1936.         {

  1937.             fprintf(pp, "%-16s", "Reduction");

  1938.         }

  1939.         else if (op == "Relu")

  1940.         {

  1941.             fprintf(pp, "%-16s", "ReLU");

  1942.         }

  1943.         else if (op == "Reshape")

  1944.         {

  1945.             if (node.input_size() == 1 || node.input_size() == 2)

  1946.             {

  1947.                 const std::string& input_name = node.input(0);

  1948. 

  1949.                 // skip weight reshape

  1950.                 if (weights.find(input_name) != weights.end())

  1951.                 {

  1952.                     continue;

  1953.                 }

  1954.             }

  1955.             fprintf(pp, "%-16s", "Reshape");

  1956.         }

  1957.         else if (op == "ShuffleChannel")

  1958.         {

  1959.             fprintf(pp, "%-16s", "ShuffleChannel");

  1960.         }

  1961.         else if (op == "Sigmoid")

  1962.         {

  1963.             fprintf(pp, "%-16s", "Sigmoid");

  1964.         }

  1965.         else if (op == "Sin")

  1966.         {

  1967.             fprintf(pp, "%-16s", "UnaryOp");

  1968.         }

  1969.         else if (op == "Slice")

  1970.         {

  1971.             fprintf(pp, "%-16s", "Crop");

  1972.         }

  1973.         else if (op == "Softmax")

  1974.         {

  1975.             fprintf(pp, "%-16s", "Softmax");

  1976.         }

  1977.         else if (op == "Split")

  1978.         {

  1979.             fprintf(pp, "%-16s", "Slice");

  1980.         }

  1981.         else if (op == "Sqrt")

  1982.         {

  1983.             fprintf(pp, "%-16s", "UnaryOp");

  1984.         }

  1985.         else if (op == "Squeeze")

  1986.         {

  1987.             fprintf(pp, "%-16s", "Squeeze");

  1988.         }

  1989.         else if (op == "Sub")

  1990.         {

  1991.             fprintf(pp, "%-16s", "BinaryOp");

  1992.         }

  1993.         else if (op == "Sum")

  1994.         {

  1995.             fprintf(pp, "%-16s", "Eltwise");

  1996.         }

  1997.         else if (op == "Swish")

  1998.         {

  1999.             fprintf(pp, "%-16s", "Swish");

  2000.         }

  2001.         else if (op == "Tan")

  2002.         {

  2003.             fprintf(pp, "%-16s", "UnaryOp");

  2004.         }

  2005.         else if (op == "Tanh")

  2006.         {

  2007.             fprintf(pp, "%-16s", "UnaryOp");

  2008.         }

  2009.         else if (op == "Transpose")

  2010.         {

  2011.             fprintf(pp, "%-16s", "Permute");

  2012.         }

  2013.         else if (op == "Upsample" || op == "Resize")

  2014.         {

  2015.             fprintf(pp, "%-16s", "Interp");

  2016.         }

  2017.         else if (op == "Unsqueeze")

  2018.         {

  2019.             fprintf(pp, "%-16s", "ExpandDims");

  2020.         }

  2021.         else

  2022.         {

  2023.             // TODO

  2024.             fprintf(stderr, "%s not supported yet!\n", op.c_str());

  2025.             fprintf(pp, "%-16s", op.c_str());

  2026.         }

  2027. 

  2028.         fprintf(pp, " %-24s %d %d", name.c_str(), input_size, output_size);

  2029. 

  2030.         for (int j = 0; j < input_size; j++)

  2031.         {

  2032.             std::string input_name = node.input(j);

  2033. 

  2034.             // check weight

  2035.             if (weights.find(input_name) != weights.end())

  2036.             {

  2037.                 continue;

  2038.             }

  2039. 

  2040.             if (node_reference.find(input_name) != node_reference.end())

  2041.             {

  2042.                 int refidx = node_reference[input_name] - 1;

  2043.                 node_reference[input_name] = refidx;

  2044. 

  2045.                 char splitsuffix[256];

  2046.                 sprintf(splitsuffix, "_splitncnn_%d", refidx);

  2047.                 input_name = input_name + splitsuffix;

  2048.             }

  2049. 

  2050.             fprintf(pp, " %s", input_name.c_str());

  2051.         }

  2052. 

  2053.         for (int j = 0; j < output_size; j++)

  2054.         {

  2055.             const std::string& output_name = node.output(j);

  2056. 

  2057.             fprintf(pp, " %s", output_name.c_str());

  2058.         }

  2059. 

  2060.         if (op == "Abs")

  2061.         {

  2062.             int op_type = 0;

  2063.             fprintf(pp, " 0=%d", op_type);

  2064.         }

  2065.         else if (op == "Acos")

  2066.         {

  2067.             int op_type = 13;

  2068.             fprintf(pp, " 0=%d", op_type);

  2069.         }

  2070.         else if (op == "Add")

  2071.         {

  2072.             int op_type = 0;

  2073.             fprintf(pp, " 0=%d", op_type);

  2074.         }

  2075.         else if (op == "Asin")

  2076.         {

  2077.             int op_type = 12;

  2078.             fprintf(pp, " 0=%d", op_type);

  2079.         }

  2080.         else if (op == "Atan")

  2081.         {

  2082.             int op_type = 14;

  2083.             fprintf(pp, " 0=%d", op_type);

  2084.         }

  2085.         else if (op == "AveragePool" || op == "MaxPool")

  2086.         {

  2087.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  2088.             int ceil_mode = get_node_attr_i(node, "ceil_mode", 0);

  2089.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  2090.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  2091.             std::vector<int> pads = get_node_attr_ai(node, "pads");

  2092. 

  2093.             int pool = op == "AveragePool" ? 1 : 0;

  2094.             int pad_mode = 1;

  2095. 

  2096.             if (auto_pad == "SAME_UPPER")

  2097.             {

  2098.                 pad_mode = 2;

  2099.             }

  2100.             else if (auto_pad == "SAME_LOWER")

  2101.             {

  2102.                 pad_mode = 3;

  2103.             }

  2104. 

  2105.             if (ceil_mode == 1)

  2106.             {

  2107.                 pad_mode = 0;

  2108.             }

  2109. 

  2110.             fprintf(pp, " 0=%d", pool);

  2111. 

  2112.             if (kernel_shape.size() == 1)

  2113.             {

  2114.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  2115.             }

  2116.             else if (kernel_shape.size() == 2)

  2117.             {

  2118.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  2119.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  2120.             }

  2121. 

  2122.             if (strides.size() == 1)

  2123.             {

  2124.                 fprintf(pp, " 2=%d", strides[0]);

  2125.             }

  2126.             else if (strides.size() == 2)

  2127.             {

  2128.                 fprintf(pp, " 2=%d", strides[1]);

  2129.                 fprintf(pp, " 12=%d", strides[0]);

  2130.             }

  2131. 

  2132.             if (pads.size() == 1)

  2133.             {

  2134.                 fprintf(pp, " 3=%d", pads[0]);

  2135.             }

  2136.             else if (pads.size() == 2)

  2137.             {

  2138.                 fprintf(pp, " 3=%d", pads[1]);

  2139.                 fprintf(pp, " 13=%d", pads[0]);

  2140.             }

  2141.             else if (pads.size() == 4)

  2142.             {

  2143.                 fprintf(pp, " 3=%d", pads[1]);

  2144.                 fprintf(pp, " 13=%d", pads[0]);

  2145.                 fprintf(pp, " 14=%d", pads[3]);

  2146.                 fprintf(pp, " 15=%d", pads[2]);

  2147.             }

  2148. 

  2149.             fprintf(pp, " 5=%d", pad_mode);

  2150. 

  2151.             if (op == "AveragePool")

  2152.             {

  2153.                 int avgpool_count_include_pad = get_node_attr_i(node, "count_include_pad", 0);

  2154.                 fprintf(pp, " 6=%d", avgpool_count_include_pad);

  2155.             }

  2156.         }

  2157.         else if (op == "BatchNormalization")

  2158.         {

  2159.             float epsilon = get_node_attr_f(node, "epsilon", 1e-5f);

  2160. 

  2161.             const onnx::TensorProto& scale = weights[node.input(1)];

  2162.             const onnx::TensorProto& B = weights[node.input(2)];

  2163.             const onnx::TensorProto& mean = weights[node.input(3)];

  2164.             const onnx::TensorProto& var = weights[node.input(4)];

  2165. 

  2166.             int channels = get_tensor_proto_data_size(scale);

  2167. 

  2168.             fprintf(pp, " 0=%d", channels);

  2169. 

  2170.             fwrite_tensor_proto_data(scale, bp);

  2171.             fwrite_tensor_proto_data(mean, bp);

  2172.             // apply epsilon to var

  2173.             {

  2174.                 const float* v = var.has_raw_data() ? (const float*)var.raw_data().data() : var.float_data().data();

  2175. 

  2176.                 for (int j = 0; j < channels; j++)

  2177.                 {

  2178.                     float ve = v[j] + epsilon;

  2179.                     fwrite(&ve, sizeof(float), 1, bp);

  2180.                 }

  2181.             }

  2182.             fwrite_tensor_proto_data(B, bp);

  2183.         }

  2184.         else if (op == "Ceil")

  2185.         {

  2186.             int op_type = 3;

  2187.             fprintf(pp, " 0=%d", op_type);

  2188.         }

  2189.         else if (op == "Clip")

  2190.         {

  2191.             float min;

  2192.             float max;

  2193.             if (node.input_size() == 1)

  2194.             {

  2195.                 min = get_node_attr_f(node, "min", -FLT_MAX);

  2196.                 max = get_node_attr_f(node, "max", FLT_MAX);

  2197.             }

  2198.             else

  2199.             {

  2200.                 const onnx::TensorProto& min_tp = weights[node.input(1)];

  2201.                 const onnx::TensorProto& max_tp = weights[node.input(2)];

  2202.                 const float* min_data = min_tp.has_raw_data() ? (const float*)min_tp.raw_data().data() : min_tp.float_data().data();

  2203.                 const float* max_data = max_tp.has_raw_data() ? (const float*)max_tp.raw_data().data() : max_tp.float_data().data();

  2204. 

  2205.                 min = min_data[0];

  2206.                 max = max_data[0];

  2207.             }

  2208. 

  2209.             fprintf(pp, " 0=%e", min);

  2210.             fprintf(pp, " 1=%e", max);

  2211.         }

  2212.         else if (op == "Concat")

  2213.         {

  2214.             int axis = get_node_attr_i(node, "axis", 1);

  2215.             fprintf(pp, " 0=%d", axis - 1);

  2216.         }

  2217.         else if (op == "Constant")

  2218.         {

  2219.             // check weight before BinaryOp

  2220.             if (binaryop_weights.find(name) != binaryop_weights.end())

  2221.             {

  2222.                 const onnx::TensorProto& M = binaryop_weights[name];

  2223. 

  2224.                 if (M.dims_size() == 0)

  2225.                 {

  2226.                     fprintf(pp, " 0=%d", get_tensor_proto_data_size(M));

  2227.                 }

  2228.                 else if (M.dims_size() == 1)

  2229.                 {

  2230.                     fprintf(pp, " 0=%d", (int)M.dims(0));

  2231.                 }

  2232.                 else if (M.dims_size() == 2)

  2233.                 {

  2234.                     fprintf(pp, " 0=%d", (int)M.dims(1));

  2235.                 }

  2236.                 else if (M.dims_size() == 3)

  2237.                 {

  2238.                     fprintf(pp, " 0=%d", (int)M.dims(2));

  2239.                     fprintf(pp, " 1=%d", (int)M.dims(1));

  2240.                 }

  2241.                 else if (M.dims_size() == 4)

  2242.                 {

  2243.                     fprintf(pp, " 0=%d", (int)M.dims(3));

  2244.                     fprintf(pp, " 1=%d", (int)M.dims(2));

  2245.                     fprintf(pp, " 2=%d", (int)M.dims(1));

  2246.                 }

  2247. 

  2248.                 fwrite_tensor_proto_data(M, bp);

  2249.             }

  2250.         }

  2251.         else if (op == "Conv")

  2252.         {

  2253.             const onnx::TensorProto& W = weights[node.input(1)];

  2254. 

  2255.             int num_filter = W.dims(0);

  2256.             int has_bias = node.input_size() == 3 ? 1 : 0;

  2257. 

  2258.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  2259.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  2260.             std::vector<int> dilations = get_node_attr_ai(node, "dilations");

  2261.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  2262.             std::vector<int> pads = get_node_attr_ai(node, "pads");

  2263.             int group = get_node_attr_i(node, "group", 1);

  2264. 

  2265.             fprintf(pp, " 0=%d", num_filter);

  2266. 

  2267.             if (kernel_shape.size() == 1)

  2268.             {

  2269.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  2270.             }

  2271.             else if (kernel_shape.size() == 2)

  2272.             {

  2273.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  2274.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  2275.             }

  2276. 

  2277.             if (dilations.size() == 1)

  2278.             {

  2279.                 fprintf(pp, " 2=%d", dilations[0]);

  2280.             }

  2281.             else if (dilations.size() == 2)

  2282.             {

  2283.                 fprintf(pp, " 2=%d", dilations[1]);

  2284.                 fprintf(pp, " 12=%d", dilations[0]);

  2285.             }

  2286. 

  2287.             if (strides.size() == 1)

  2288.             {

  2289.                 fprintf(pp, " 3=%d", strides[0]);

  2290.             }

  2291.             else if (strides.size() == 2)

  2292.             {

  2293.                 fprintf(pp, " 3=%d", strides[1]);

  2294.                 fprintf(pp, " 13=%d", strides[0]);

  2295.             }

  2296. 

  2297.             if (auto_pad == "SAME_UPPER")

  2298.             {

  2299.                 fprintf(pp, " 4=-233");

  2300.             }

  2301.             else if (auto_pad == "SAME_LOWER")

  2302.             {

  2303.                 fprintf(pp, " 4=-234");

  2304.             }

  2305.             else

  2306.             {

  2307.                 if (pads.size() == 1)

  2308.                 {

  2309.                     fprintf(pp, " 4=%d", pads[0]);

  2310.                 }

  2311.                 else if (pads.size() == 2)

  2312.                 {

  2313.                     fprintf(pp, " 4=%d", pads[1]);

  2314.                     fprintf(pp, " 14=%d", pads[0]);

  2315.                 }

  2316.                 else if (pads.size() == 4)

  2317.                 {

  2318.                     fprintf(pp, " 4=%d", pads[1]);

  2319.                     fprintf(pp, " 14=%d", pads[0]);

  2320.                     fprintf(pp, " 15=%d", pads[3]);

  2321.                     fprintf(pp, " 16=%d", pads[2]);

  2322.                 }

  2323.             }

  2324. 

  2325.             fprintf(pp, " 5=%d", has_bias);

  2326. 

  2327.             fprintf(pp, " 6=%d", get_tensor_proto_data_size(W));

  2328. 

  2329.             if (group > 1)

  2330.             {

  2331.                 fprintf(pp, " 7=%d", group);

  2332.             }

  2333. 

  2334.             int quantize_tag = 0;

  2335.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  2336. 

  2337.             fwrite_tensor_proto_data(W, bp);

  2338. 

  2339.             if (has_bias)

  2340.             {

  2341.                 const onnx::TensorProto& B = weights[node.input(2)];

  2342.                 fwrite_tensor_proto_data(B, bp);

  2343.             }

  2344.         }

  2345.         else if (op == "ConvTranspose")

  2346.         {

  2347.             const onnx::TensorProto& W = weights[node.input(1)];

  2348. 

  2349.             int has_bias = node.input_size() == 3 ? 1 : 0;

  2350. 

  2351.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  2352.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  2353.             std::vector<int> dilations = get_node_attr_ai(node, "dilations");

  2354.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  2355.             std::vector<int> output_padding = get_node_attr_ai(node, "output_padding");

  2356.             std::vector<int> output_shape = get_node_attr_ai(node, "output_shape");

  2357.             std::vector<int> pads = get_node_attr_ai(node, "pads");

  2358.             int group = get_node_attr_i(node, "group", 1);

  2359.             int num_filter = W.dims(1) * group;

  2360. 

  2361.             fprintf(pp, " 0=%d", num_filter);

  2362. 

  2363.             if (kernel_shape.size() == 1)

  2364.             {

  2365.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  2366.             }

  2367.             else if (kernel_shape.size() == 2)

  2368.             {

  2369.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  2370.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  2371.             }

  2372. 

  2373.             if (dilations.size() == 1)

  2374.             {

  2375.                 fprintf(pp, " 2=%d", dilations[0]);

  2376.             }

  2377.             else if (dilations.size() == 2)

  2378.             {

  2379.                 fprintf(pp, " 2=%d", dilations[1]);

  2380.                 fprintf(pp, " 12=%d", dilations[0]);

  2381.             }

  2382. 

  2383.             if (strides.size() == 1)

  2384.             {

  2385.                 fprintf(pp, " 3=%d", strides[0]);

  2386.             }

  2387.             else if (strides.size() == 2)

  2388.             {

  2389.                 fprintf(pp, " 3=%d", strides[1]);

  2390.                 fprintf(pp, " 13=%d", strides[0]);

  2391.             }

  2392. 

  2393.             if (auto_pad == "SAME_UPPER")

  2394.             {

  2395.                 fprintf(pp, " 4=-233");

  2396.             }

  2397.             else if (auto_pad == "SAME_LOWER")

  2398.             {

  2399.                 fprintf(pp, " 4=-234");

  2400.             }

  2401.             else

  2402.             {

  2403.                 if (pads.size() == 1)

  2404.                 {

  2405.                     fprintf(pp, " 4=%d", pads[0]);

  2406.                 }

  2407.                 else if (pads.size() == 2)

  2408.                 {

  2409.                     fprintf(pp, " 4=%d", pads[1]);

  2410.                     fprintf(pp, " 14=%d", pads[0]);

  2411.                 }

  2412.                 else if (pads.size() == 4)

  2413.                 {

  2414.                     fprintf(pp, " 4=%d", pads[1]);

  2415.                     fprintf(pp, " 14=%d", pads[0]);

  2416.                     fprintf(pp, " 15=%d", pads[3]);

  2417.                     fprintf(pp, " 16=%d", pads[2]);

  2418.                 }

  2419.             }

  2420. 

  2421.             if (output_padding.size() == 1)

  2422.             {

  2423.                 fprintf(pp, " 18=%d", output_padding[0]);

  2424.             }

  2425.             else if (output_padding.size() == 2)

  2426.             {

  2427.                 fprintf(pp, " 18=%d", output_padding[1]);

  2428.                 fprintf(pp, " 19=%d", output_padding[0]);

  2429.             }

  2430. 

  2431.             if (output_shape.size() == 1)

  2432.             {

  2433.                 fprintf(pp, " 20=%d", output_shape[0]);

  2434.             }

  2435.             else if (output_shape.size() == 2)

  2436.             {

  2437.                 fprintf(pp, " 20=%d", output_shape[1]);

  2438.                 fprintf(pp, " 21=%d", output_shape[0]);

  2439.             }

  2440. 

  2441.             fprintf(pp, " 5=%d", has_bias);

  2442. 

  2443.             fprintf(pp, " 6=%d", get_tensor_proto_data_size(W));

  2444. 

  2445.             if (group > 1)

  2446.             {

  2447.                 fprintf(pp, " 7=%d", group);

  2448.             }

  2449. 

  2450.             int quantize_tag = 0;

  2451.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  2452. 

  2453.             int maxk = 0;

  2454.             if (kernel_shape.size() == 2)

  2455.             {

  2456.                 maxk = kernel_shape[1] * kernel_shape[0];

  2457.             }

  2458.             else

  2459.             {

  2460.                 maxk = kernel_shape[0] * kernel_shape[0];

  2461.             }

  2462.             int weight_data_size = get_tensor_proto_data_size(W);

  2463.             const float* weight_data = 0;

  2464.             if (W.has_raw_data())

  2465.             {

  2466.                 weight_data = (const float*)W.raw_data().data();

  2467.             }

  2468.             else if (W.data_type() == 1)

  2469.             {

  2470.                 weight_data = W.float_data().data();

  2471.             }

  2472.             for (int g = 0; g < group; g++)

  2473.             {

  2474.                 // reorder weight from inch-outch to outch-inch

  2475.                 int num_filter_g = num_filter / group;

  2476.                 int num_input = weight_data_size / maxk / num_filter_g / group;

  2477.                 const float* weight_data_ptr = weight_data + g * maxk * num_filter_g * num_input;

  2478.                 for (int k = 0; k < num_filter_g; k++)

  2479.                 {

  2480.                     for (int j = 0; j < num_input; j++)

  2481.                     {

  2482.                         fwrite(weight_data_ptr + (j * num_filter_g + k) * maxk, sizeof(float), maxk, bp);

  2483.                     }

  2484.                 }

  2485.             }

  2486. 

  2487.             if (has_bias)

  2488.             {

  2489.                 const onnx::TensorProto& B = weights[node.input(2)];

  2490.                 fwrite_tensor_proto_data(B, bp);

  2491.             }

  2492.         }

  2493.         else if (op == "Cos")

  2494.         {

  2495.             int op_type = 10;

  2496.             fprintf(pp, " 0=%d", op_type);

  2497.         }

  2498.         else if (op == "DepthToSpace")

  2499.         {

  2500.             // pixelshuffle

  2501.             std::string mode = get_node_attr_s(node, "mode");

  2502.             if (mode == "CRD")

  2503.             {

  2504.                 int scale_factor = get_node_attr_i(node, "blocksize", 1);

  2505.                 fprintf(pp, " 0=%d", scale_factor);

  2506.             }

  2507.             else

  2508.             {

  2509.                 fprintf(stderr, "Unsupported DepthToSpace mode %s!\n", mode.c_str());

  2510.             }

  2511.         }

  2512.         else if (op == "Div")

  2513.         {

  2514.             int op_type = 3;

  2515.             fprintf(pp, " 0=%d", op_type);

  2516.         }

  2517.         else if (op == "Dropout")

  2518.         {

  2519.             // no-op

  2520.         }

  2521.         else if (op == "Elu")

  2522.         {

  2523.             float alpha = get_node_attr_f(node, "alpha", 1.f);

  2524.             fprintf(pp, " 0=%e", alpha);

  2525.         }

  2526.         else if (op == "Exp")

  2527.         {

  2528.             int op_type = 7;

  2529.             fprintf(pp, " 0=%d", op_type);

  2530.         }

  2531.         else if (op == "Flatten")

  2532.         {

  2533.             int axis = get_node_attr_i(node, "axis", 1);

  2534.             if (axis != 1)

  2535.             {

  2536.                 fprintf(stderr, "Unsupported Flatten axis %d!\n", axis);

  2537.             }

  2538.         }

  2539.         else if (op == "Floor")

  2540.         {

  2541.             int op_type = 2;

  2542.             fprintf(pp, " 0=%d", op_type);

  2543.         }

  2544.         else if (op == "Gemm")

  2545.         {

  2546.             float alpha = get_node_attr_f(node, "alpha", 1.f);

  2547.             float beta = get_node_attr_f(node, "beta", 1.f);

  2548.             int transA = get_node_attr_i(node, "transA", 0);

  2549.             int transB = get_node_attr_i(node, "transB", 0);

  2550. 

  2551.             if (alpha == 1.f && beta == 1.f)

  2552.             {

  2553.                 // InnerProduct-like A * B + C

  2554.                 if (transA == 0 && transB == 1)

  2555.                 {

  2556.                     const onnx::TensorProto& B = weights[node.input(1)];

  2557.                     const onnx::TensorProto& C = weights[node.input(2)];

  2558. 

  2559.                     fprintf(pp, " 0=%d", get_tensor_proto_data_size(C));

  2560.                     fprintf(pp, " 1=1");

  2561.                     fprintf(pp, " 2=%d", get_tensor_proto_data_size(B));

  2562. 

  2563.                     int quantize_tag = 0;

  2564.                     fwrite(&quantize_tag, sizeof(int), 1, bp);

  2565. 

  2566.                     fwrite_tensor_proto_data(B, bp);

  2567.                     fwrite_tensor_proto_data(C, bp);

  2568.                 }

  2569.             }

  2570.         }

  2571.         else if (op == "GlobalAveragePool")

  2572.         {

  2573.             int pool = 1;

  2574.             int global_pool = 1;

  2575. 

  2576.             fprintf(pp, " 0=%d", pool);

  2577.             fprintf(pp, " 4=%d", global_pool);

  2578.         }

  2579.         else if (op == "GlobalMaxPool")

  2580.         {

  2581.             int pool = 0;

  2582.             int global_pool = 1;

  2583. 

  2584.             fprintf(pp, " 0=%d", pool);

  2585.             fprintf(pp, " 4=%d", global_pool);

  2586.         }

  2587.         else if (op == "HardSigmoid")

  2588.         {

  2589.             float alpha = get_node_attr_f(node, "alpha", 0.2f);

  2590.             float beta = get_node_attr_f(node, "beta", 0.5f);

  2591. 

  2592.             fprintf(pp, " 0=%e", alpha);

  2593.             fprintf(pp, " 1=%e", beta);

  2594.         }

  2595.         else if (op == "HardSwish")

  2596.         {

  2597.             float alpha = get_node_attr_f(node, "alpha", 0.2f);

  2598.             float beta = get_node_attr_f(node, "beta", 0.5f);

  2599. 

  2600.             fprintf(pp, " 0=%e", alpha);

  2601.             fprintf(pp, " 1=%e", beta);

  2602.         }

  2603.         else if (op == "ImageScaler")

  2604.         {

  2605.             std::vector<float> bias = get_node_attr_af(node, "bias");

  2606.             float scale = get_node_attr_f(node, "scale", 1.f);

  2607. 

  2608.             int channels = bias.size();

  2609. 

  2610.             fprintf(pp, " 0=%d", channels);

  2611.             fprintf(pp, " 1=1");

  2612. 

  2613.             for (int j = 0; j < channels; j++)

  2614.             {

  2615.                 fwrite(&scale, sizeof(float), 1, bp);

  2616.             }

  2617.             fwrite(&bias[0], sizeof(float), channels, bp);

  2618.         }

  2619.         else if (op == "InstanceNormalization")

  2620.         {

  2621.             float eps = get_node_attr_f(node, "epsilon", 1e-5f);

  2622.             const onnx::TensorProto& scale = weights[node.input(1)];

  2623.             const onnx::TensorProto& B = weights[node.input(2)];

  2624.             int channels = get_tensor_proto_data_size(scale);

  2625. 

  2626.             fprintf(pp, " 0=%d", channels);

  2627.             fprintf(pp, " 1=%e", eps);

  2628.             fwrite_tensor_proto_data(scale, bp);

  2629.             fwrite_tensor_proto_data(B, bp);

  2630.         }

  2631.         else if (op == "LeakyRelu")

  2632.         {

  2633.             float alpha = get_node_attr_f(node, "alpha", 0.01f);

  2634. 

  2635.             fprintf(pp, " 0=%e", alpha);

  2636.         }

  2637.         else if (op == "Log")

  2638.         {

  2639.             int op_type = 8;

  2640.             fprintf(pp, " 0=%d", op_type);

  2641.         }

  2642.         else if (op == "LRN")

  2643.         {

  2644.             float alpha = get_node_attr_f(node, "alpha", 1.f);

  2645.             float beta = get_node_attr_f(node, "beta", 0.5f);

  2646.             float bias = get_node_attr_f(node, "bias", 1.f);

  2647.             int size = get_node_attr_i(node, "size", 1);

  2648. 

  2649.             int norm_region = 0;

  2650. 

  2651.             fprintf(pp, " 0=%d", norm_region);

  2652.             fprintf(pp, " 1=%d", size);

  2653.             fprintf(pp, " 2=%e", alpha);

  2654.             fprintf(pp, " 3=%e", beta);

  2655.             fprintf(pp, " 4=%e", bias);

  2656.         }

  2657.         else if (op == "LSTM")

  2658.         {

  2659.             const onnx::TensorProto& W = weights[node.input(1)];

  2660.             const onnx::TensorProto& R = weights[node.input(2)];

  2661.             const onnx::TensorProto& B = weights[node.input(3)];

  2662. 

  2663.             int hidden_size = get_node_attr_i(node, "hidden_size", 0);

  2664.             std::string direction = get_node_attr_s(node, "direction");

  2665. 

  2666.             int direction_type = 0;

  2667.             if (direction == "forward")

  2668.             {

  2669.                 direction_type = 0;

  2670.             }

  2671.             else if (direction == "reverse")

  2672.             {

  2673.                 direction_type = 1;

  2674.             }

  2675.             else if (direction == "bidirectional")

  2676.             {

  2677.                 direction_type = 2;

  2678.             }

  2679. 

  2680.             int weight_data_size = get_tensor_proto_data_size(W);

  2681. 

  2682.             fprintf(pp, " 0=%d", hidden_size);

  2683.             fprintf(pp, " 1=%d", weight_data_size);

  2684.             fprintf(pp, " 2=%d", direction_type);

  2685. 

  2686.             int num_directions = direction_type == 2 ? 2 : 1;

  2687. 

  2688.             int quantize_tag = 0;

  2689. 

  2690.             // reorder num_directions-IOFG-hidden-size to num_directions-IFOG-hidden-size

  2691.             {

  2692.                 fwrite(&quantize_tag, sizeof(int), 1, bp);

  2693. 

  2694.                 int weight_data_size_g = get_tensor_proto_data_size(W) / 4 / num_directions;

  2695.                 const float* wptr = W.has_raw_data() ? (const float*)W.raw_data().data() : W.float_data().data();

  2696. 

  2697.                 const float* iptr = wptr;

  2698.                 const float* optr = wptr + weight_data_size_g;

  2699.                 const float* fptr = wptr + weight_data_size_g * 2;

  2700.                 const float* gptr = wptr + weight_data_size_g * 3;

  2701.                 fwrite(iptr, sizeof(float), weight_data_size_g, bp);

  2702.                 fwrite(fptr, sizeof(float), weight_data_size_g, bp);

  2703.                 fwrite(optr, sizeof(float), weight_data_size_g, bp);

  2704.                 fwrite(gptr, sizeof(float), weight_data_size_g, bp);

  2705. 

  2706.                 if (direction_type == 2)

  2707.                 {

  2708.                     iptr += weight_data_size_g * 4;

  2709.                     optr += weight_data_size_g * 4;

  2710.                     fptr += weight_data_size_g * 4;

  2711.                     gptr += weight_data_size_g * 4;

  2712.                     fwrite(iptr, sizeof(float), weight_data_size_g, bp);

  2713.                     fwrite(fptr, sizeof(float), weight_data_size_g, bp);

  2714.                     fwrite(optr, sizeof(float), weight_data_size_g, bp);

  2715.                     fwrite(gptr, sizeof(float), weight_data_size_g, bp);

  2716.                 }

  2717.             }

  2718. 

  2719.             // reduce xc and hc bias

  2720.             // reorder num_directions-IOFG-hidden to num_directions-IFOG-hidden

  2721.             {

  2722.                 fwrite(&quantize_tag, sizeof(int), 1, bp);

  2723. 

  2724.                 int bias_data_size_g = get_tensor_proto_data_size(B) / 2 / 4 / num_directions;

  2725.                 const float* xcbptr = B.has_raw_data() ? (const float*)B.raw_data().data() : B.float_data().data();

  2726.                 const float* xiptr = xcbptr;

  2727.                 const float* xoptr = xcbptr + bias_data_size_g;

  2728.                 const float* xfptr = xcbptr + bias_data_size_g * 2;

  2729.                 const float* xgptr = xcbptr + bias_data_size_g * 3;

  2730.                 const float* hiptr = xcbptr + bias_data_size_g * 4;

  2731.                 const float* hoptr = xcbptr + bias_data_size_g * 5;

  2732.                 const float* hfptr = xcbptr + bias_data_size_g * 6;

  2733.                 const float* hgptr = xcbptr + bias_data_size_g * 7;

  2734. 

  2735.                 for (int j = 0; j < bias_data_size_g; j++)

  2736.                 {

  2737.                     float vb = xiptr[j] + hiptr[j];

  2738.                     fwrite(&vb, sizeof(float), 1, bp);

  2739.                 }

  2740.                 for (int j = 0; j < bias_data_size_g; j++)

  2741.                 {

  2742.                     float vb = xfptr[j] + hfptr[j];

  2743.                     fwrite(&vb, sizeof(float), 1, bp);

  2744.                 }

  2745.                 for (int j = 0; j < bias_data_size_g; j++)

  2746.                 {

  2747.                     float vb = xoptr[j] + hoptr[j];

  2748.                     fwrite(&vb, sizeof(float), 1, bp);

  2749.                 }

  2750.                 for (int j = 0; j < bias_data_size_g; j++)

  2751.                 {

  2752.                     float vb = xgptr[j] + hgptr[j];

  2753.                     fwrite(&vb, sizeof(float), 1, bp);

  2754.                 }

  2755. 

  2756.                 if (direction_type == 2)

  2757.                 {

  2758.                     xiptr += bias_data_size_g * 8;

  2759.                     xoptr += bias_data_size_g * 8;

  2760.                     xfptr += bias_data_size_g * 8;

  2761.                     xgptr += bias_data_size_g * 8;

  2762.                     hiptr += bias_data_size_g * 8;

  2763.                     hoptr += bias_data_size_g * 8;

  2764.                     hfptr += bias_data_size_g * 8;

  2765.                     hgptr += bias_data_size_g * 8;

  2766. 

  2767.                     for (int j = 0; j < bias_data_size_g; j++)

  2768.                     {

  2769.                         float vb = xiptr[j] + hiptr[j];

  2770.                         fwrite(&vb, sizeof(float), 1, bp);

  2771.                     }

  2772.                     for (int j = 0; j < bias_data_size_g; j++)

  2773.                     {

  2774.                         float vb = xfptr[j] + hfptr[j];

  2775.                         fwrite(&vb, sizeof(float), 1, bp);

  2776.                     }

  2777.                     for (int j = 0; j < bias_data_size_g; j++)

  2778.                     {

  2779.                         float vb = xoptr[j] + hoptr[j];

  2780.                         fwrite(&vb, sizeof(float), 1, bp);

  2781.                     }

  2782.                     for (int j = 0; j < bias_data_size_g; j++)

  2783.                     {

  2784.                         float vb = xgptr[j] + hgptr[j];

  2785.                         fwrite(&vb, sizeof(float), 1, bp);

  2786.                     }

  2787.                 }

  2788.             }

  2789. 

  2790.             // reorder num_directions-IOFG-hidden-hidden to num_directions-IFOG-hidden-hidden

  2791.             {

  2792.                 fwrite(&quantize_tag, sizeof(int), 1, bp);

  2793. 

  2794.                 int weight_data_size_g = get_tensor_proto_data_size(R) / 4 / num_directions;

  2795.                 const float* rptr = R.has_raw_data() ? (const float*)R.raw_data().data() : R.float_data().data();

  2796. 

  2797.                 const float* iptr = rptr;

  2798.                 const float* optr = rptr + weight_data_size_g;

  2799.                 const float* fptr = rptr + weight_data_size_g * 2;

  2800.                 const float* gptr = rptr + weight_data_size_g * 3;

  2801.                 fwrite(iptr, sizeof(float), weight_data_size_g, bp);

  2802.                 fwrite(fptr, sizeof(float), weight_data_size_g, bp);

  2803.                 fwrite(optr, sizeof(float), weight_data_size_g, bp);

  2804.                 fwrite(gptr, sizeof(float), weight_data_size_g, bp);

  2805. 

  2806.                 if (direction_type == 2)

  2807.                 {

  2808.                     iptr += weight_data_size_g * 4;

  2809.                     optr += weight_data_size_g * 4;

  2810.                     fptr += weight_data_size_g * 4;

  2811.                     gptr += weight_data_size_g * 4;

  2812.                     fwrite(iptr, sizeof(float), weight_data_size_g, bp);

  2813.                     fwrite(fptr, sizeof(float), weight_data_size_g, bp);

  2814.                     fwrite(optr, sizeof(float), weight_data_size_g, bp);

  2815.                     fwrite(gptr, sizeof(float), weight_data_size_g, bp);

  2816.                 }

  2817.             }

  2818.         }

  2819.         else if (op == "MatMul")

  2820.         {

  2821.             const onnx::TensorProto& B = weights[node.input(1)];

  2822. 

  2823.             int weight_data_size = get_tensor_proto_data_size(B);

  2824. 

  2825.             int num_output = B.dims(B.dims_size() - 1);

  2826.             int num_input = weight_data_size / num_output;

  2827. 

  2828.             fprintf(pp, " 0=%d", num_output);

  2829.             fprintf(pp, " 1=0");

  2830.             fprintf(pp, " 2=%d", weight_data_size);

  2831. 

  2832.             int quantize_tag = 0;

  2833.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  2834. 

  2835.             // reorder num_input-num_output to num_output-num_input

  2836.             {

  2837.                 const float* bptr = B.has_raw_data() ? (const float*)B.raw_data().data() : B.float_data().data();

  2838. 

  2839.                 for (int j = 0; j < num_output; j++)

  2840.                 {

  2841.                     for (int k = 0; k < num_input; k++)

  2842.                     {

  2843.                         float vb = bptr[k * num_output + j];

  2844.                         fwrite(&vb, sizeof(float), 1, bp);

  2845.                     }

  2846.                 }

  2847.             }

  2848. 

  2849.             //                 fwrite_tensor_proto_data(B, bp)

  2850.         }

  2851.         else if (op == "Max")

  2852.         {

  2853.             int op_type = 4;

  2854.             fprintf(pp, " 0=%d", op_type);

  2855.         }

  2856.         else if (op == "Min")

  2857.         {

  2858.             int op_type = 5;

  2859.             fprintf(pp, " 0=%d", op_type);

  2860.         }

  2861.         else if (op == "Mul")

  2862.         {

  2863.             int op_type = 2;

  2864.             fprintf(pp, " 0=%d", op_type);

  2865.         }

  2866.         else if (op == "Neg")

  2867.         {

  2868.             int op_type = 1;

  2869.             fprintf(pp, " 0=%d", op_type);

  2870.         }

  2871.         else if (op == "Normalize")

  2872.         {

  2873.             float eps = get_node_attr_f(node, "eps", 0.f);

  2874.             int scale_data_size = 1;

  2875. 

  2876.             fprintf(pp, " 1=1"); // channel_shared

  2877.             fprintf(pp, " 2=%e", eps);

  2878.             fprintf(pp, " 3=%d", scale_data_size);

  2879.             fprintf(pp, " 9=1"); // TODO hardcode pytorch style

  2880. 

  2881.             const float scale_data[1] = {1.f};

  2882.             fwrite(scale_data, sizeof(float), 1, bp);

  2883.         }

  2884.         else if (op == "Pad")

  2885.         {

  2886.             std::string mode = get_node_attr_s(node, "mode");

  2887.             float value = get_node_attr_f(node, "value", 0.f);

  2888. 

  2889.             std::vector<int> pads;

  2890.             if (node.input_size() == 1)

  2891.             {

  2892.                 pads = get_node_attr_ai(node, "pads");

  2893.             }

  2894.             else

  2895.             {

  2896.                 pads = get_node_attr_from_input_ai(weights[node.input(1)]);

  2897.             }

  2898. 

  2899.             int type = 0;

  2900.             if (mode == "constant")

  2901.             {

  2902.                 type = 0;

  2903.             }

  2904.             else if (mode == "edge")

  2905.             {

  2906.                 type = 1;

  2907.             }

  2908.             else if (mode == "reflect")

  2909.             {

  2910.                 type = 2;

  2911.             }

  2912. 

  2913.             int pad_size = pads.size();

  2914.             int top, bottom, left, right;

  2915.             if (pad_size == 8)

  2916.             {

  2917.                 //NCHW

  2918.                 top = pads[2];

  2919.                 bottom = pads[6];

  2920.                 left = pads[3];

  2921.                 right = pads[7];

  2922.             }

  2923.             else if (pad_size == 6)

  2924.             {

  2925.                 //CHW

  2926.                 top = pads[1];

  2927.                 bottom = pads[4];

  2928.                 left = pads[2];

  2929.                 right = pads[5];

  2930.             }

  2931.             else

  2932.             {

  2933.                 //HW

  2934.                 top = pads[0];

  2935.                 bottom = pads[2];

  2936.                 left = pads[1];

  2937.                 right = pads[3];

  2938.             }

  2939. 

  2940.             fprintf(pp, " 0=%d", top);

  2941.             fprintf(pp, " 1=%d", bottom);

  2942.             fprintf(pp, " 2=%d", left);

  2943.             fprintf(pp, " 3=%d", right);

  2944.             fprintf(pp, " 4=%d", type);

  2945.             fprintf(pp, " 5=%e", value);

  2946.         }

  2947.         else if (op == "Pow")

  2948.         {

  2949.             int op_type = 6;

  2950.             fprintf(pp, " 0=%d", op_type);

  2951.         }

  2952.         else if (op == "PixelShuffle")

  2953.         {

  2954.             int scale_factor = get_node_attr_i(node, "scale_factor", 1);

  2955.             fprintf(pp, " 0=%d", scale_factor);

  2956.         }

  2957.         else if (op == "PRelu")

  2958.         {

  2959.             const onnx::TensorProto& slope = weights[node.input(1)];

  2960. 

  2961.             int num_slope = get_tensor_proto_data_size(slope);

  2962. 

  2963.             fprintf(pp, " 0=%d", num_slope);

  2964. 

  2965.             fwrite_tensor_proto_data(slope, bp);

  2966.         }

  2967.         else if (op == "Reciprocal")

  2968.         {

  2969.             int op_type = 15;

  2970.             fprintf(pp, " 0=%d", op_type);

  2971.         }

  2972.         else if (op == "ReduceMax" || op == "ReduceMin" || op == "ReduceMean" || op == "ReduceProd" || op == "ReduceSum" || op == "ReduceSumSquare" || op == "ReduceL1" || op == "ReduceL2" || op == "ReduceLogSum" || op == "ReduceLogSumExp")

  2973.         {

  2974.             int op_type = -233;

  2975.             if (op == "ReduceSum")

  2976.                 op_type = 0;

  2977.             else if (op == "ReduceSumSquare")

  2978.                 op_type = 2;

  2979.             else if (op == "ReduceMean")

  2980.                 op_type = 3;

  2981.             else if (op == "ReduceMax")

  2982.                 op_type = 4;

  2983.             else if (op == "ReduceMin")

  2984.                 op_type = 5;

  2985.             else if (op == "ReduceProd")

  2986.                 op_type = 6;

  2987.             else if (op == "ReduceL1")

  2988.                 op_type = 7;

  2989.             else if (op == "ReduceL2")

  2990.                 op_type = 8;

  2991.             else if (op == "ReduceLogSum")

  2992.                 op_type = 9;

  2993.             else if (op == "ReduceLogSumExp")

  2994.                 op_type = 10;

  2995.             fprintf(pp, " 0=%d", op_type);

  2996. 

  2997.             std::vector<int> axes = get_node_attr_ai(node, "axes");

  2998.             int keepdims = get_node_attr_i(node, "keepdims", 1);

  2999. 

  3000.             if (axes.size() > 0)

  3001.             {

  3002.                 // if axes set, reduce according to axes

  3003.                 fprintf(pp, " 1=%d", 0);

  3004.                 fprintf(pp, " -23303=%zu", axes.size());

  3005.                 for (int i = 0; i < axes.size(); i++)

  3006.                 {

  3007.                     if (axes[i] == 0 || axes[i] > 3 || axes[i] < -3)

  3008.                         fprintf(stderr, "Unsupported reduction axes !\n");

  3009.                     fprintf(pp, ",%d", axes[i]);

  3010.                 }

  3011.             }

  3012.             else

  3013.             {

  3014.                 // if axes not set, reduce all axes by default

  3015.                 fprintf(pp, " 1=%d", 1);

  3016.             }

  3017.             fprintf(pp, " 4=%d", keepdims);

  3018.         }

  3019.         else if (op == "Reshape")

  3020.         {

  3021.             std::vector<int> shape;

  3022. 

  3023.             if (node.input_size() == 1)

  3024.             {

  3025.                 shape = get_node_attr_ai(node, "shape");

  3026.             }

  3027.             else

  3028.             {

  3029.                 shape = get_node_attr_from_input_ai(weights[node.input(1)]);

  3030.             }

  3031. 

  3032.             if (shape.size() == 1)

  3033.             {

  3034.                 fprintf(pp, " 0=%d", shape[0]); // should never reach here

  3035.             }

  3036.             else if (shape.size() == 2)

  3037.             {

  3038.                 fprintf(pp, " 0=%d", shape[1]);

  3039.             }

  3040.             else if (shape.size() == 3)

  3041.             {

  3042.                 fprintf(pp, " 0=%d", shape[2]);

  3043.                 fprintf(pp, " 1=%d", shape[1]);

  3044.             }

  3045.             else if (shape.size() == 4)

  3046.             {

  3047.                 fprintf(pp, " 0=%d", shape[3]);

  3048.                 fprintf(pp, " 1=%d", shape[2]);

  3049.                 fprintf(pp, " 2=%d", shape[1]);

  3050.             }

  3051.             else if (shape.size() == 5)

  3052.             {

  3053.                 fprintf(pp, " 0=%d", shape[4] * shape[3]);

  3054.                 fprintf(pp, " 1=%d", shape[2]);

  3055.                 fprintf(pp, " 2=%d", shape[1]);

  3056.             }

  3057.         }

  3058.         else if (op == "Resize")

  3059.         {

  3060.             std::string mode = get_node_attr_s(node, "mode");

  3061. 

  3062.             std::vector<float> scales;

  3063.             std::vector<int> sizes;

  3064.             if (node.input_size() == 2)

  3065.             {

  3066.                 // opset 10

  3067.                 scales = get_node_attr_from_input_af(weights[node.input(1)]);

  3068.             }

  3069.             else

  3070.             {

  3071.                 // opset 11+

  3072.                 scales = get_node_attr_from_input_af(weights[node.input(2)]);

  3073.                 sizes = get_node_attr_from_input_ai(weights[node.input(3)]);

  3074.             }

  3075. 

  3076.             int resize_type = 1;

  3077.             if (mode == "nearest")

  3078.             {

  3079.                 resize_type = 1;

  3080.             }

  3081.             else if (mode == "linear")

  3082.             {

  3083.                 resize_type = 2;

  3084.             }

  3085.             else if (mode == "cubic")

  3086.             {

  3087.                 resize_type = 3;

  3088.             }

  3089. 

  3090.             if (scales.empty() && sizes.empty())

  3091.             {

  3092.                 fprintf(stderr, "Unsupported Resize scales and sizes are all empty!\n");

  3093.             }

  3094. 

  3095.             float h_scale = 1.f;

  3096.             float w_scale = 1.f;

  3097.             if (scales.size() == 2)

  3098.             {

  3099.                 w_scale = scales[1];

  3100.             }

  3101.             else if (scales.size() == 3)

  3102.             {

  3103.                 h_scale = scales[1];

  3104.                 w_scale = scales[2];

  3105.             }

  3106.             else if (scales.size() == 4)

  3107.             {

  3108.                 h_scale = scales[2];

  3109.                 w_scale = scales[3];

  3110. 

  3111.                 if (scales[1] != 1.f)

  3112.                     fprintf(stderr, "Unsupported Resize scales !\n");

  3113.             }

  3114. 

  3115.             int output_height = 0;

  3116.             int output_width = 0;

  3117.             if (sizes.size() == 2)

  3118.             {

  3119.                 output_width = sizes[1];

  3120.             }

  3121.             else if (sizes.size() == 3)

  3122.             {

  3123.                 output_height = sizes[1];

  3124.                 output_width = sizes[2];

  3125.             }

  3126.             else if (sizes.size() == 4)

  3127.             {

  3128.                 output_height = sizes[2];

  3129.                 output_width = sizes[3];

  3130.             }

  3131. 

  3132.             fprintf(pp, " 0=%d", resize_type);

  3133.             fprintf(pp, " 1=%e", h_scale);

  3134.             fprintf(pp, " 2=%e", w_scale);

  3135.             fprintf(pp, " 3=%d", output_height);

  3136.             fprintf(pp, " 4=%d", output_width);

  3137.         }

  3138.         else if (op == "ShuffleChannel")

  3139.         {

  3140.             int group = get_node_attr_i(node, "group", 1);

  3141.             int reverse = get_node_attr_i(node, "reverse", 0);

  3142.             fprintf(pp, " 0=%d", group);

  3143.             fprintf(pp, " 1=%d", reverse);

  3144.         }

  3145.         else if (op == "Sigmoid")

  3146.         {

  3147.         }

  3148.         else if (op == "Sin")

  3149.         {

  3150.             int op_type = 9;

  3151.             fprintf(pp, " 0=%d", op_type);

  3152.         }

  3153.         else if (op == "Slice")

  3154.         {

  3155.             std::vector<int> starts;

  3156.             std::vector<int> ends;

  3157.             std::vector<int> axes;

  3158.             std::vector<int> steps;

  3159.             if (node.input_size() == 1)

  3160.             {

  3161.                 starts = get_node_attr_ai(node, "starts");

  3162.                 ends = get_node_attr_ai(node, "ends");

  3163.                 axes = get_node_attr_ai(node, "axes");

  3164.                 steps = get_node_attr_ai(node, "steps"); // TODO

  3165.             }

  3166.             else

  3167.             {

  3168.                 starts = get_node_attr_from_input_ai(weights[node.input(1)]);

  3169.                 ends = get_node_attr_from_input_ai(weights[node.input(2)]);

  3170.                 if (node.input_size() >= 4)

  3171.                     axes = get_node_attr_from_input_ai(weights[node.input(3)]);

  3172.                 if (node.input_size() >= 5)

  3173.                     steps = get_node_attr_from_input_ai(weights[node.input(4)]);

  3174.             }

  3175. 

  3176.             // assert step == 1

  3177.             for (int i = 0; i < (int)steps.size(); i++)

  3178.             {

  3179.                 if (steps[i] != 1)

  3180.                     fprintf(stderr, "Unsupported slice step !\n");

  3181.             }

  3182. 

  3183.             // filter out N-dim axis

  3184.             if (!axes.empty())

  3185.             {

  3186.                 for (int i = 0; i < (int)axes.size(); i++)

  3187.                 {

  3188.                     int axis = axes[i];

  3189.                     if (axis == 0)

  3190.                     {

  3191.                         starts.erase(starts.begin() + i);

  3192.                         ends.erase(ends.begin() + i);

  3193.                         axes.erase(axes.begin() + i);

  3194.                         break;

  3195.                     }

  3196.                 }

  3197.             }

  3198. 

  3199.             fprintf(pp, " -23309=%d", (int)starts.size());

  3200.             for (int i = 0; i < (int)starts.size(); i++)

  3201.             {

  3202.                 fprintf(pp, ",%d", starts[i]);

  3203.             }

  3204.             fprintf(pp, " -23310=%d", (int)ends.size());

  3205.             for (int i = 0; i < (int)ends.size(); i++)

  3206.             {

  3207.                 fprintf(pp, ",%d", ends[i]);

  3208.             }

  3209.             if (!axes.empty())

  3210.             {

  3211.                 fprintf(pp, " -23311=%d", (int)axes.size());

  3212.                 for (int i = 0; i < (int)axes.size(); i++)

  3213.                 {

  3214.                     int axis = axes[i];

  3215.                     if (axis == 0 || axis > 3 || axis < -3)

  3216.                         fprintf(stderr, "Unsupported slice axes !\n");

  3217. 

  3218.                     if (axis > 0)

  3219.                         axis = axis - 1; // -1 for skip N-dim

  3220. 

  3221.                     fprintf(pp, ",%d", axis);

  3222.                 }

  3223.             }

  3224.         }

  3225.         else if (op == "Softmax")

  3226.         {

  3227.             int axis = get_node_attr_i(node, "axis", 1);

  3228.             fprintf(pp, " 0=%d", axis - 1);

  3229.             fprintf(pp, " 1=1");

  3230.         }

  3231.         else if (op == "Split")

  3232.         {

  3233.             int axis = get_node_attr_i(node, "axis", 0);

  3234.             std::vector<int> split = get_node_attr_ai(node, "split");

  3235.             if (axis < 1)

  3236.                 fprintf(stderr, "Unsupported split axis !\n");

  3237. 

  3238.             fprintf(pp, " -23300=%d", output_size);

  3239.             if (split.empty())

  3240.             {

  3241.                 for (int i = 0; i < output_size; i++)

  3242.                 {

  3243.                     fprintf(pp, ",-233");

  3244.                 }

  3245.             }

  3246.             else

  3247.             {

  3248.                 for (int i = 0; i < split.size() - 1; i++)

  3249.                 {

  3250.                     fprintf(pp, ",%d", split[i]);

  3251.                 }

  3252.                 fprintf(pp, ",-233");

  3253.             }

  3254.             fprintf(pp, " 1=%d", axis - 1);

  3255.         }

  3256.         else if (op == "Sqrt")

  3257.         {

  3258.             int op_type = 5;

  3259.             fprintf(pp, " 0=%d", op_type);

  3260.         }

  3261.         else if (op == "Squeeze")

  3262.         {

  3263.             std::vector<int> axes = get_node_attr_ai(node, "axes");

  3264. 

  3265.             if (axes.empty())

  3266.             {

  3267.                 fprintf(pp, " 0=1");

  3268.                 fprintf(pp, " 1=1");

  3269.                 fprintf(pp, " 2=1");

  3270.             }

  3271.             else

  3272.             {

  3273.                 fprintf(pp, " -23303=%zu", axes.size());

  3274.                 for (int i = 0; i < (int)axes.size(); i++)

  3275.                 {

  3276.                     if (axes[i] == 0 || axes[i] > 3 || axes[i] < -3)

  3277.                         fprintf(stderr, "Unsupported squeeze axes !\n");

  3278.                     fprintf(pp, ",%d", axes[i]);

  3279.                 }

  3280.             }

  3281.         }

  3282.         else if (op == "Sub")

  3283.         {

  3284.             int op_type = 1;

  3285.             fprintf(pp, " 0=%d", op_type);

  3286.         }

  3287.         else if (op == "Sum")

  3288.         {

  3289.             int op_type = 1;

  3290.             fprintf(pp, " 0=%d", op_type);

  3291.         }

  3292.         else if (op == "Swish")

  3293.         {

  3294.         }

  3295.         else if (op == "Tan")

  3296.         {

  3297.             int op_type = 11;

  3298.             fprintf(pp, " 0=%d", op_type);

  3299.         }

  3300.         else if (op == "Tanh")

  3301.         {

  3302.             int op_type = 16;

  3303.             fprintf(pp, " 0=%d", op_type);

  3304.         }

  3305.         else if (op == "Transpose")

  3306.         {

  3307.             std::vector<int> perm = get_node_attr_ai(node, "perm");

  3308. 

  3309.             if (perm.size() == 4)

  3310.             {

  3311.                 if (perm[1] == 1 && perm[2] == 2 && perm[3] == 3)

  3312.                     fprintf(pp, " 0=0"); // w h c

  3313.                 else if (perm[1] == 1 && perm[2] == 3 && perm[3] == 2)

  3314.                     fprintf(pp, " 0=1"); // h w c

  3315.                 else if (perm[1] == 2 && perm[2] == 1 && perm[3] == 3)

  3316.                     fprintf(pp, " 0=2"); // w c h

  3317.                 else if (perm[1] == 2 && perm[2] == 3 && perm[3] == 1)

  3318.                     fprintf(pp, " 0=3"); // c w h

  3319.                 else if (perm[1] == 3 && perm[2] == 1 && perm[3] == 2)

  3320.                     fprintf(pp, " 0=4"); // h c w

  3321.                 else if (perm[1] == 3 && perm[2] == 2 && perm[3] == 1)

  3322.                     fprintf(pp, " 0=5"); // c h w

  3323.             }

  3324.             else if (perm.size() == 5)

  3325.             {

  3326.                 if (perm[1] == 1 && perm[2] == 2 && perm[3] == 3 && perm[4] == 4)

  3327.                     fprintf(pp, " 0=0"); // wx h c

  3328.                 else if (perm[1] == 1 && perm[2] == 3 && perm[3] == 4 && perm[4] == 2)

  3329.                     fprintf(pp, " 0=1"); // h wx c

  3330.                 else if (perm[1] == 2 && perm[2] == 1 && perm[3] == 3 && perm[4] == 4)

  3331.                     fprintf(pp, " 0=2"); // wx c h

  3332.                 else if (perm[1] == 2 && perm[2] == 3 && perm[3] == 4 && perm[4] == 1)

  3333.                     fprintf(pp, " 0=3"); // c wx h

  3334.                 else if (perm[1] == 3 && perm[2] == 4 && perm[3] == 1 && perm[4] == 2)

  3335.                     fprintf(pp, " 0=4"); // h c wx

  3336.                 else if (perm[1] == 3 && perm[2] == 4 && perm[3] == 2 && perm[4] == 1)

  3337.                     fprintf(pp, " 0=5"); // c h wx

  3338.                 else

  3339.                     fprintf(stderr, "Unsupported transpose type !\n");

  3340.             }

  3341.         }

  3342.         else if (op == "Upsample")

  3343.         {

  3344.             std::string mode = get_node_attr_s(node, "mode");

  3345. 

  3346.             std::vector<float> scales;

  3347. 

  3348.             if (node.input_size() == 1)

  3349.             {

  3350.                 scales = get_node_attr_af(node, "scales");

  3351.             }

  3352.             else

  3353.             {

  3354.                 scales = get_node_attr_from_input_af(weights[node.input(1)]);

  3355.             }

  3356. 

  3357.             int resize_type = 1;

  3358.             if (mode == "nearest")

  3359.             {

  3360.                 resize_type = 1;

  3361.             }

  3362.             else if (mode == "bilinear" || mode == "linear")

  3363.             {

  3364.                 resize_type = 2;

  3365.             }

  3366.             else if (mode == "trilinear")

  3367.             {

  3368.                 fprintf(stderr, "Unsupported Upsample mode !\n");

  3369.             }

  3370. 

  3371.             float h_scale = 1.f;

  3372.             float w_scale = 1.f;

  3373.             if (scales.size() == 2)

  3374.             {

  3375.                 w_scale = scales[1];

  3376.             }

  3377.             else if (scales.size() == 3)

  3378.             {

  3379.                 h_scale = scales[1];

  3380.                 w_scale = scales[2];

  3381.             }

  3382.             else if (scales.size() == 4)

  3383.             {

  3384.                 h_scale = scales[2];

  3385.                 w_scale = scales[3];

  3386. 

  3387.                 if (scales[1] != 1.f)

  3388.                     fprintf(stderr, "Unsupported Upsample scales !\n");

  3389.             }

  3390.             else

  3391.             {

  3392.                 fprintf(stderr, "Unsupported Upsample scales !\n");

  3393.             }

  3394. 

  3395.             fprintf(pp, " 0=%d", resize_type);

  3396.             fprintf(pp, " 1=%e", h_scale);

  3397.             fprintf(pp, " 2=%e", w_scale);

  3398.         }

  3399.         else if (op == "Unsqueeze")

  3400.         {

  3401.             std::vector<int> axes = get_node_attr_ai(node, "axes");

  3402. 

  3403.             fprintf(pp, " -23303=%zu", axes.size());

  3404.             for (int i = 0; i < (int)axes.size(); i++)

  3405.             {

  3406.                 if (axes[i] == 0 || axes[i] > 4 || axes[i] < -4)

  3407.                     fprintf(stderr, "Unsupported unsqueeze axes !\n");

  3408.                 fprintf(pp, ",%d", axes[i]);

  3409.             }

  3410.         }

  3411.         else

  3412.         {

  3413.             // TODO op specific param

  3414.             for (int j = 0; j < node.attribute_size(); j++)

  3415.             {

  3416.                 const onnx::AttributeProto& attr = node.attribute(j);

  3417.                 if (attr.type() == 1)

  3418.                 {

  3419.                     fprintf(stderr, "  # %s=%g\n", attr.name().c_str(), attr.f());

  3420.                 }

  3421.                 else if (attr.type() == 2)

  3422.                 {

  3423.                     fprintf(stderr, "  # %s=%ld\n", attr.name().c_str(), attr.i());

  3424.                 }

  3425.                 else if (attr.type() == 3)

  3426.                 {

  3427.                     fprintf(stderr, "  # %s=%s\n", attr.name().c_str(), attr.s().c_str());

  3428.                 }

  3429.                 else

  3430.                 {

  3431.                     fprintf(stderr, "  # %s %d\n", attr.name().c_str(), attr.type());

  3432.                 }

  3433.             }

  3434.         }

  3435. 

  3436.         fprintf(pp, "\n");

  3437. 

  3438.         for (int j = 0; j < output_size; j++)

  3439.         {

  3440.             const std::string& output_name = node.output(j);

  3441.             if (node_reference.find(output_name) != node_reference.end())

  3442.             {

  3443.                 int refcount = node_reference[output_name];

  3444.                 if (refcount > 1)

  3445.                 {

  3446.                     char splitname[256];

  3447.                     sprintf(splitname, "splitncnn_%d", internal_split);

  3448.                     fprintf(pp, "%-16s %-24s %d %d", "Split", splitname, 1, refcount);

  3449. 

  3450.                     fprintf(pp, " %s", output_name.c_str());

  3451. 

  3452.                     for (int k = 0; k < refcount; k++)

  3453.                     {

  3454.                         fprintf(pp, " %s_splitncnn_%d", output_name.c_str(), k);

  3455.                     }

  3456.                     fprintf(pp, "\n");

  3457. 

  3458.                     internal_split++;

  3459.                 }

  3460.             }

  3461.         }

  3462.     }

  3463. 

  3464.     fclose(pp);

  3465.     fclose(bp);

  3466. 

  3467.     return 0;

  3468. }