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: 61ba8ec68e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61ba8ec68e'
${ noResults }
ncnn/tools/onnx/onnx2ncnn.cpp

2346 lines
76 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 <float.h>

  16. #include <stdio.h>

  17. #include <limits.h>

  18. 

  19. #include <iostream>

  20. 

  21. #include <fstream>

  22. #include <set>

  23. #include <limits>

  24. #include <algorithm>

  25. 

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

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

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

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

  30. 

  31. #include "onnx.pb.h"

  32. 

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

  34. {

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

  36.     if (!fs.is_open())

  37.     {

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

  39.         return false;

  40.     }

  41. 

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

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

  44. 

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

  46. 

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

  48. 

  49.     fs.close();

  50. 

  51.     return success;

  52. }

  53. 

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

  55. {

  56.     std::vector<int> v;

  57. 

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

  59.     {

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

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

  62.         {

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

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

  65.             {

  66.                 v[j] = attr.ints(j);

  67.             }

  68. 

  69.             break;

  70.         }

  71.     }

  72. 

  73.     return v;

  74. }

  75. 

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

  77. {

  78.     std::vector<float> v;

  79. 

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

  81.     {

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

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

  84.         {

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

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

  87.             {

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

  89.             }

  90. 

  91.             break;

  92.         }

  93.     }

  94. 

  95.     return v;

  96. }

  97. 

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

  99. {

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

  101.     {

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

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

  104.         {

  105.             return attr.i();

  106.         }

  107.     }

  108. 

  109.     return def;

  110. }

  111. 

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

  113. {

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

  115.     {

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

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

  118.         {

  119.             return attr.f();

  120.         }

  121.     }

  122. 

  123.     return def;

  124. }

  125. 

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

  127. {

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

  129.     {

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

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

  132.         {

  133.             return attr.s();

  134.         }

  135.     }

  136. 

  137.     return def;

  138. }

  139. 

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

  141. {

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

  143.     {

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

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

  146.         {

  147.             return attr.t();

  148.         }

  149.     }

  150. 

  151.     return onnx::TensorProto();

  152. }

  153. 

  154. static std::vector<int> get_tensor_proto_reshape_shape(const onnx::TensorProto& tp)

  155. {

  156.     const int64_t* shape_data = 0;

  157.     int size = 0;

  158. 

  159.     // int64

  160.     if (tp.has_raw_data())

  161.     {

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

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

  164.     }

  165.     else if (tp.data_type() == 7)

  166.     {

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

  168.         size = tp.int64_data_size();

  169.     }

  170. 

  171.     std::vector<int> shape;

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

  173.     {

  174.         shape.push_back(shape_data[j]);

  175.     }

  176. 

  177.     return shape;

  178. }

  179. 

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

  181. {

  182.     if (tp.has_raw_data())

  183.     {

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

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

  186.         return size;

  187.     }

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

  189.     {

  190.         return tp.float_data_size();

  191.     }

  192. 

  193.     return 0;

  194. }

  195. 

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

  197. {

  198.     int size = get_tensor_proto_data_size(tp);

  199. 

  200.     if (tp.has_raw_data())

  201.     {

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

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

  204.     }

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

  206.     {

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

  208.     }

  209. }

  210. 

  211. 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)

  212. {

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

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

  215.     {

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

  217. 

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

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

  220.         {

  221.             // check weight

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

  223.                 continue;

  224. 

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

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

  227.                 continue;

  228. 

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

  230.                 continue;

  231. 

  232.             // perm = (1, 0)

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

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

  235.                 continue;

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

  237.                 continue;

  238. 

  239.             if (i+1 >= node_count)

  240.                 continue;

  241. 

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

  243. 

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

  245.                 continue;

  246. 

  247.             // reduce

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

  249. 

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

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

  252. 

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

  254. 

  255.             // permute weight

  256.             {

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

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

  259. 

  260.                 std::vector<float> permuted_data;

  261.                 permuted_data.reserve(h * w);

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

  263. 

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

  265.                 {

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

  267.                     {

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

  269.                         permuted_data.push_back(vb);

  270.                     }

  271.                 }

  272. 

  273.                 B.set_dims(0, w);

  274.                 B.set_dims(1, h);

  275. 

  276.                 if (B.has_raw_data())

  277.                 {

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

  279.                 }

  280.                 else

  281.                 {

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

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

  284.                 }

  285.             }

  286. 

  287.             reduced_node_count += 1;

  288.             i += 1;

  289.         }

  290.     }

  291. }

  292. 

  293. 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)

  294. {

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

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

  297.     {

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

  299. 

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

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

  302.         {

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

  304.                 continue;

  305. 

  306.             std::vector<int> shape;

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

  308.             {

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

  310.             }

  311.             else

  312.             {

  313.                 shape = get_tensor_proto_reshape_shape(weights[node->input(1)]);

  314.             }

  315. 

  316.             // 1 groups channels_per_group, height, width

  317.             if (shape.size() != 5)

  318.                 continue;

  319. 

  320.             if (shape[0] != 1)

  321.                 continue;

  322. 

  323.             if (i+2 >= node_count)

  324.                 continue;

  325. 

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

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

  328. 

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

  330.                 continue;

  331. 

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

  333.                 continue;

  334. 

  335.             // 0 2 1 3 4

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

  337.             if (perm.size() != 5)

  338.                 continue;

  339. 

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

  341.                 continue;

  342. 

  343.             std::vector<int> shape3;

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

  345.             {

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

  347.             }

  348.             else

  349.             {

  350.                 shape3 = get_tensor_proto_reshape_shape(weights[node3->input(1)]);

  351.             }

  352. 

  353.             // 1, -1, height, width

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

  355.                 continue;

  356. 

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

  358.                 continue;

  359. 

  360.             // reduce

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

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

  363. 

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

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

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

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

  368. 

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

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

  371. 

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

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

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

  375. 

  376.             reduced_node_count += 2;

  377.             i += 2;

  378.         }

  379.     }

  380. }

  381. 

  382. 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)

  383. {

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

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

  386.     {

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

  388. 

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

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

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

  392.         {

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

  394.                 continue;

  395. 

  396.             if (i+3 >= node_count)

  397.                 continue;

  398. 

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

  400.                 continue;

  401. 

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

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

  404.                 continue;

  405. 

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

  407.             if (constant_add_three != 3.f)

  408.                 continue;

  409. 

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

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

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

  413. 

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

  415.                 continue;

  416. 

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

  418.                 continue;

  419. 

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

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

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

  423.                 continue;

  424. 

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

  426.                 continue;

  427. 

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

  429.                 continue;

  430. 

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

  432.                 continue;

  433. 

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

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

  436.                 continue;

  437. 

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

  439.             if (constant_div_six != 6.f)

  440.                 continue;

  441. 

  442.             // reduce

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

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

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

  446. 

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

  448. 

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

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

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

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

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

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

  455. 

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

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

  458. 

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

  460.             node4->clear_input();

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

  462. 

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

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

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

  466. 

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

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

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

  470. 

  471.             reduced_node_count += 3;

  472.             i += 3;

  473.         }

  474.     }

  475. 

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

  477.     {

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

  479. 

  480.         // HardSwish <= HardSigmoid - Mul

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

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

  483.         {

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

  485.                 continue;

  486. 

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

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

  489. 

  490.             if (i+1 >= node_count)

  491.                 continue;

  492. 

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

  494. 

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

  496.                 continue;

  497. 

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

  499.                 continue;

  500. 

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

  502.                 continue;

  503. 

  504.             // reduce

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

  506. 

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

  508. 

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

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

  511. 

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

  513.             node2->clear_input();

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

  515. 

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

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

  518.             attr_alpha->set_f(alpha);

  519. 

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

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

  522.             attr_beta->set_f(beta);

  523. 

  524.             reduced_node_count += 1;

  525.             i += 1;

  526.         }

  527.     }

  528. }

  529. 

  530. 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)

  531. {

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

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

  534.     {

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

  536. 

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

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

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

  540.         {

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

  542.                 continue;

  543. 

  544.             if (i+2 >= node_count)

  545.                 continue;

  546. 

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

  548.                 continue;

  549. 

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

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

  552.                 continue;

  553. 

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

  555.             if (constant_add_three != 3.f)

  556.                 continue;

  557. 

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

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

  560. 

  561.             if (node2->op_type() != "Clip" || node3->op_type() != "Div")

  562.                 continue;

  563. 

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

  565.                 continue;

  566. 

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

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

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

  570.                 continue;

  571. 

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

  573.                 continue;

  574. 

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

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

  577.                 continue;

  578. 

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

  580.             if (constant_div_six != 6.f)

  581.                 continue;

  582. 

  583.             // reduce

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

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

  586. 

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

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

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

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

  591. 

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

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

  594. 

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

  596.             node3->clear_input();

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

  598. 

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

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

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

  602. 

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

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

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

  606. 

  607.             reduced_node_count += 2;

  608.             i += 2;

  609.         }

  610.     }

  611. }

  612. 

  613. 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)

  614. {

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

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

  617.     {

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

  619. 

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

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

  622.         {

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

  624.                 continue;

  625. 

  626.             if (i+2 >= node_count)

  627.                 continue;

  628. 

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

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

  631. 

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

  633.                 continue;

  634. 

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

  636.                 continue;

  637. 

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

  639.                 continue;

  640. 

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

  642.                 continue;

  643. 

  644.             // reduce

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

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

  647. 

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

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

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

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

  652. 

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

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

  655. 

  656.             reduced_node_count += 2;

  657.             i += 2;

  658.         }

  659.     }

  660. }

  661. 

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

  663. {

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

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

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

  667. 

  668.     onnx::ModelProto model;

  669. 

  670.     // load

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

  672.     if (!s1)

  673.     {

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

  675.         return -1;

  676.     }

  677. 

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

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

  680. 

  681.     // magic

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

  683. 

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

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

  686. 

  687.     int node_count = graph.node_size();

  688. 

  689.     // node reference

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

  691. 

  692.     // weight node and weight reshape node

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

  694. 

  695.     // weight node before BinaryOp

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

  697. 

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

  699.     {

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

  701. 

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

  703. 

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

  705.     }

  706. 

  707.     // global definition line

  708.     // [layer count] [blob count]

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

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

  711.     {

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

  713. 

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

  715. 

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

  717.         if (name.empty())

  718.         {

  719.             name = node.output(0);

  720.         }

  721. 

  722.         if (op == "Constant")

  723.         {

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

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

  726.             continue;

  727.         }

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

  729.         {

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

  731.             {

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

  733. 

  734.                 // check weight

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

  736.                 {

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

  738.                     continue;

  739.                 }

  740.             }

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

  742.             {

  743.                 // opset 5

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

  745. 

  746.                 // check weight

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

  748.                 {

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

  750. 

  751.                     // set weight shape directly

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

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

  754. 

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

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

  757.                     {

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

  759.                     }

  760. 

  761.                     continue;

  762.                 }

  763.             }

  764.         }

  765.         else

  766.         {

  767.             bool isBinaryOp = false;

  768.             if (op == "Add" || op == "Mul" || op == "Div")

  769.             {

  770.                 isBinaryOp = true;

  771.             }

  772. 

  773.             if (isBinaryOp)

  774.             {

  775.                 // check weights

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

  777.                 {

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

  779. 

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

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

  782.                     {

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

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

  785.                         weights.erase(it);

  786.                     }

  787.                 }

  788.             }

  789.         }

  790. 

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

  792.         {

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

  794. 

  795.             // check weight

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

  797.             {

  798.                 continue;

  799.             }

  800. 

  801.             blob_names.insert(input_name);

  802. 

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

  804.             {

  805.                 node_reference[input_name] = 1;

  806.             }

  807.             else

  808.             {

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

  810.             }

  811.         }

  812. 

  813.         if (op == "Dropout")

  814.         {

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

  816.             blob_names.insert(output_name);

  817.             continue;

  818.         }

  819. 

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

  821.         {

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

  823. 

  824.             blob_names.insert(output_name);

  825.         }

  826.     }

  827. 

  828.     // include Input node

  829.     int input_node_count = 0;

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

  831.     {

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

  833. 

  834.         // check weight

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

  836.             continue;

  837. 

  838.         // check weight before BinaryOp

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

  840.             continue;

  841. 

  842.         blob_names.insert(input_name);

  843. 

  844.         input_node_count++;

  845.     }

  846. 

  847.     // op chain fusion

  848.     int reduced_node_count = 0;

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

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

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

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

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

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

  855. 

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

  857.     int splitncnn_blob_count = 0;

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

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

  860.     {

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

  862.         {

  863.             node_reference.erase(it++);

  864.         }

  865.         else

  866.         {

  867.             splitncnn_blob_count += it->second;

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

  869.             ++it;

  870.         }

  871.     }

  872. 

  873.     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);

  874. 

  875.     int internal_split = 0;

  876. 

  877.     // place Input at the beginning

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

  879.     {

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

  881. 

  882.         // check weight

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

  884.             continue;

  885. 

  886.         // check weight before BinaryOp

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

  888.             continue;

  889. 

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

  891. 

  892.         // split the input

  893.         if (node_reference.find(input_name) == node_reference.end()){

  894.             continue;

  895.         }

  896. 

  897.         int refcount = node_reference[input_name];

  898.         if (refcount <= 1){

  899.             continue;

  900.         }

  901. 

  902.         char splitname[256];

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

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

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

  906. 

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

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

  909.         }

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

  911.     }

  912. 

  913.     // place MemoryData next

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

  915.     {

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

  917. 

  918.         // check weight before BinaryOp

  919.         if (binaryop_weights.find(input_name) == binaryop_weights.end())

  920.             continue;

  921. 

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

  923.             continue;

  924. 

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

  926. 

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

  928. 

  929.         if (M.dims_size() == 0) {

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

  931.         } else if (M.dims_size() == 1) {

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

  933.         } else if (M.dims_size() == 2) {

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

  935.         } else if (M.dims_size() == 3) {

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

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

  938.         } else if (M.dims_size() == 4) {

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

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

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

  942.         }

  943. 

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

  945. 

  946.         fwrite_tensor_proto_data(M, bp);

  947. 

  948.         // split the input

  949.         if (node_reference.find(input_name) == node_reference.end()){

  950.             continue;

  951.         }

  952. 

  953.         int refcount = node_reference[input_name];

  954.         if (refcount <= 1){

  955.             continue;

  956.         }   

  957. 

  958.         char splitname[256];

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

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

  961. 

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

  963. 

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

  965.         {

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

  967.         }

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

  969. 

  970.         internal_split++;

  971. 

  972.     }

  973. 

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

  975.     {

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

  977. 

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

  979. 

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

  981. 

  982.         if (op == "noop_reducedncnn")

  983.         {

  984.             continue;

  985.         }

  986. 

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

  988.         if (name.empty())

  989.         {

  990.             name = node.output(0);

  991.         }

  992. 

  993.         int input_size = node.input_size();

  994.         int output_size = node.output_size();

  995. 

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

  997.         {

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

  999. 

  1000.             // check weight

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

  1002.             {

  1003.                 input_size--;

  1004.             }

  1005. 

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

  1007.         }

  1008.         /*

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

  1010.         {

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

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

  1013.         } 

  1014.         */

  1015. 

  1016.         if (op == "Abs")

  1017.         {

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

  1019.         }

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

  1021.         {

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

  1023.         }

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

  1025.         {

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

  1027.         }

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

  1029.         {

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

  1031.         }

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

  1033.         {

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

  1035.         }

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

  1037.         {

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

  1039.         }

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

  1041.         {

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

  1043.         }

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

  1045.         {

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

  1047.         }

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

  1049.         {

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

  1051.         }

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

  1053.         {

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

  1055.         }

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

  1057.         {

  1058.             // check weight before BinaryOp

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

  1060.             {

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

  1062.             }

  1063.             else

  1064.             {

  1065.                 continue;

  1066.             }

  1067.         }

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

  1069.         {

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

  1071.             if (group > 1) {

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

  1073.             } else {

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

  1075.             }

  1076.         }

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

  1078.         {

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

  1080.             if (group > 1) {

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

  1082.             } else {

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

  1084.             }

  1085.         }

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

  1087.         {

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

  1089.         }

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

  1091.         {

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

  1093.         }

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

  1095.         {

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

  1097.             output_size = 1;

  1098.         }

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

  1100.         {

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

  1102.         }

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

  1104.         {

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

  1106.         }

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

  1108.         {

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

  1110.         }

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

  1112.         {

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

  1114.         }

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

  1116.         {

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

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

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

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

  1121. 

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

  1123.             {

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

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

  1126.                 {

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

  1128.                 }

  1129.             }

  1130. 

  1131.             // TODO

  1132.         }

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

  1134.         {

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

  1136.         }

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

  1138.         {

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

  1140.         }

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

  1142.         {

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

  1144.         }

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

  1146.         {

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

  1148.         }

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

  1150.         {

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

  1152.         }

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

  1154.         {

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

  1156.         }

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

  1158.         {

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

  1160.         }

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

  1162.         {

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

  1164.         }

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

  1166.         {

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

  1168.         }

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

  1170.         {

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

  1172.         }

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

  1174.         {

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

  1176.         }

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

  1178.         {

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

  1180.         }

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

  1182.         {

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

  1184.         }

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

  1186.         {

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

  1188.         }

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

  1190.         {

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

  1192.         }

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

  1194.         {

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

  1196.         }

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

  1198.         {

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

  1200.         }

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

  1202.         {

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

  1204.         }

  1205.         else if (op == "ReduceMax" || op == "ReduceMin" || op == "ReduceMean" ||

  1206.                 op == "ReduceProd" || op == "ReduceSum" || op == "ReduceSumSquare" ||

  1207.                 op == "ReduceL1" || op == "ReduceL2" || op == "ReduceLogSum" || op == "ReduceLogSumExp")

  1208.         {

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

  1210.         }

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

  1212.         {

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

  1214.         }

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

  1216.         {

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

  1218.             {

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

  1220. 

  1221.                 // skip weight reshape

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

  1223.                 {

  1224.                     continue;

  1225.                 }

  1226.             }

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

  1228.         }

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

  1230.         {

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

  1232.         }

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

  1234.         {

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

  1236.         }

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

  1238.         {

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

  1240.         }

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

  1242.         {

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

  1244.         }

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

  1246.         {

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

  1248.         }

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

  1250.         {

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

  1252.         }

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

  1254.         {

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

  1256.         }

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

  1258.         {

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

  1260.         }

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

  1262.         {

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

  1264.         }

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

  1266.         {

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

  1268.         }

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

  1270.         {

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

  1272.         }

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

  1274.         {

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

  1276.         }

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

  1278.         {

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

  1280.         }

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

  1282.         {

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

  1284.         }

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

  1286.         {

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

  1288.         }

  1289.         else

  1290.         {

  1291.             // TODO

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

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

  1294.         }

  1295. 

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

  1297. 

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

  1299.         {

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

  1301. 

  1302.             // check weight

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

  1304.             {

  1305.                 continue;

  1306.             }

  1307. 

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

  1309.             {

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

  1311.                 node_reference[input_name] = refidx;

  1312. 

  1313.                 char splitsuffix[256];

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

  1315.                 input_name = input_name + splitsuffix;

  1316.             }

  1317. 

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

  1319.         }

  1320. 

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

  1322.         {

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

  1324. 

  1325.             fprintf(pp, " %s", output_name.c_str());

  1326.         }

  1327. 

  1328.         if (op == "Abs")

  1329.         {

  1330.             int op_type = 0;

  1331.             fprintf(pp, " 0=%d", op_type);

  1332.         }

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

  1334.         {

  1335.             int op_type = 13;

  1336.             fprintf(pp, " 0=%d", op_type);

  1337.         }

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

  1339.         {

  1340.             int op_type = 0;

  1341.             fprintf(pp, " 0=%d", op_type);

  1342.         }

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

  1344.         {

  1345.             int op_type = 12;

  1346.             fprintf(pp, " 0=%d", op_type);

  1347.         }

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

  1349.         {

  1350.             int op_type = 14;

  1351.             fprintf(pp, " 0=%d", op_type);

  1352.         }

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

  1354.         {

  1355.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  1356.             int ceil_mode = get_node_attr_i(node, "ceil_mode", 0);

  1357.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  1358.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  1359.             std::vector<int> pads = get_node_attr_ai(node, "pads");

  1360. 

  1361.             int pool = op == "AveragePool" ? 1 : 0;

  1362.             int pad_mode = 1;

  1363. 

  1364.             if (auto_pad == "SAME_UPPER")

  1365.             {

  1366.                 pad_mode = 2;

  1367.             }

  1368.             else if (auto_pad == "SAME_LOWER")

  1369.             {

  1370.                 pad_mode = 3;

  1371.             }

  1372. 

  1373.             if (ceil_mode == 1)

  1374.             {

  1375.                 pad_mode = 0;

  1376.             }

  1377. 

  1378.             fprintf(pp, " 0=%d", pool);

  1379. 

  1380.             if (kernel_shape.size() == 1) {

  1381.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  1382.             } else if (kernel_shape.size() == 2) {

  1383.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  1384.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  1385.             }

  1386. 

  1387.             if (strides.size() == 1) {

  1388.                 fprintf(pp, " 2=%d", strides[0]);

  1389.             } else if (strides.size() == 2) {

  1390.                 fprintf(pp, " 2=%d", strides[1]);

  1391.                 fprintf(pp, " 12=%d", strides[0]);

  1392.             }

  1393. 

  1394.             if (pads.size() == 1) {

  1395.                 fprintf(pp, " 3=%d", pads[0]);

  1396.             } else if (pads.size() == 2) {

  1397.                 fprintf(pp, " 3=%d", pads[1]);

  1398.                 fprintf(pp, " 13=%d", pads[0]);

  1399.             } else if (pads.size() == 4) {

  1400.                 fprintf(pp, " 3=%d", pads[1]);

  1401.                 fprintf(pp, " 13=%d", pads[0]);

  1402.                 fprintf(pp, " 14=%d", pads[3]);

  1403.                 fprintf(pp, " 15=%d", pads[2]);

  1404.             }

  1405. 

  1406.             fprintf(pp, " 5=%d", pad_mode);

  1407. 

  1408.             if (op == "AveragePool")

  1409.             {

  1410.                 int avgpool_count_include_pad = get_node_attr_i(node, "count_include_pad", 0);

  1411.                 fprintf(pp, " 6=%d", avgpool_count_include_pad);

  1412.             }

  1413.         }

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

  1415.         {

  1416.             float epsilon = get_node_attr_f(node, "epsilon", 1e-5f);

  1417. 

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

  1419.             const onnx::TensorProto& B = weights[node.input(2)];

  1420.             const onnx::TensorProto& mean = weights[node.input(3)];

  1421.             const onnx::TensorProto& var = weights[node.input(4)];

  1422. 

  1423.             int channels = get_tensor_proto_data_size(scale);

  1424. 

  1425.             fprintf(pp, " 0=%d", channels);

  1426. 

  1427.             fwrite_tensor_proto_data(scale, bp);

  1428.             fwrite_tensor_proto_data(mean, bp);

  1429.             // apply epsilon to var

  1430.             {

  1431.                 const float* v = var.has_raw_data() ? (const float*)var.raw_data().data() : var.float_data().data();

  1432. 

  1433.                 for (int j=0; j<channels; j++)

  1434.                 {

  1435.                     float ve = v[j] + epsilon;

  1436.                     fwrite(&ve, sizeof(float), 1, bp);

  1437.                 }

  1438.             }

  1439.             fwrite_tensor_proto_data(B, bp);

  1440.         }

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

  1442.         {

  1443.             int op_type = 3;

  1444.             fprintf(pp, " 0=%d", op_type);

  1445.         }

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

  1447.         {

  1448.             float min = get_node_attr_f(node, "min", -FLT_MAX);

  1449.             float max = get_node_attr_f(node, "max", FLT_MAX);

  1450.             fprintf(pp, " 0=%e", min);

  1451.             fprintf(pp, " 1=%e", max);

  1452.         }

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

  1454.         {

  1455.             int axis = get_node_attr_i(node, "axis", 1);

  1456.             fprintf(pp, " 0=%d", axis-1);

  1457.         }

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

  1459.         {

  1460.             // check weight before BinaryOp

  1461.             if (binaryop_weights.find(name) != binaryop_weights.end())

  1462.             {

  1463.                 const onnx::TensorProto& M = binaryop_weights[name];

  1464. 

  1465.                 if (M.dims_size() == 0) {

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

  1467.                 } else if (M.dims_size() == 1) {

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

  1469.                 } else if (M.dims_size() == 2) {

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

  1471.                 } else if (M.dims_size() == 3) {

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

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

  1474.                 } else if (M.dims_size() == 4) {

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

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

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

  1478.                 }

  1479. 

  1480.                 fwrite_tensor_proto_data(M, bp);

  1481.             }

  1482.         }

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

  1484.         {

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

  1486. 

  1487.             int num_filter = W.dims(0);

  1488.             int has_bias = node.input_size() == 3 ? 1 : 0;

  1489. 

  1490.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  1491.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  1492.             std::vector<int> dilations = get_node_attr_ai(node, "dilations");

  1493.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  1494.             std::vector<int> pads = get_node_attr_ai(node, "pads");

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

  1496. 

  1497.             fprintf(pp, " 0=%d", num_filter);

  1498. 

  1499.             if (kernel_shape.size() == 1) {

  1500.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  1501.             } else if (kernel_shape.size() == 2) {

  1502.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  1503.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  1504.             }

  1505. 

  1506.             if (dilations.size() == 1) {

  1507.                 fprintf(pp, " 2=%d", dilations[0]);

  1508.             } else if (dilations.size() == 2) {

  1509.                 fprintf(pp, " 2=%d", dilations[1]);

  1510.                 fprintf(pp, " 12=%d", dilations[0]);

  1511.             }

  1512. 

  1513.             if (strides.size() == 1) {

  1514.                 fprintf(pp, " 3=%d", strides[0]);

  1515.             } else if (strides.size() == 2) {

  1516.                 fprintf(pp, " 3=%d", strides[1]);

  1517.                 fprintf(pp, " 13=%d", strides[0]);

  1518.             }

  1519. 

  1520.             if (auto_pad == "SAME_UPPER")

  1521.             {

  1522.                 fprintf(pp, " 4=-233");

  1523.             }

  1524.             else if (auto_pad == "SAME_LOWER")

  1525.             {

  1526.                 fprintf(pp, " 4=-234");

  1527.             }

  1528.             else

  1529.             {

  1530. 

  1531.             if (pads.size() == 1) {

  1532.                 fprintf(pp, " 4=%d", pads[0]);

  1533.             } else if (pads.size() == 2) {

  1534.                 fprintf(pp, " 4=%d", pads[1]);

  1535.                 fprintf(pp, " 14=%d", pads[0]);

  1536.             } else if (pads.size() == 4) {

  1537.                 fprintf(pp, " 4=%d", pads[1]);

  1538.                 fprintf(pp, " 14=%d", pads[0]);

  1539.                 fprintf(pp, " 15=%d", pads[3]);

  1540.                 fprintf(pp, " 16=%d", pads[2]);

  1541.             }

  1542. 

  1543.             }

  1544. 

  1545.             fprintf(pp, " 5=%d", has_bias);

  1546. 

  1547.             fprintf(pp, " 6=%d", get_tensor_proto_data_size(W));

  1548. 

  1549.             if (group > 1) {

  1550.                 fprintf(pp, " 7=%d", group);

  1551.             }

  1552. 

  1553.             int quantize_tag = 0;

  1554.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  1555. 

  1556.             fwrite_tensor_proto_data(W, bp);

  1557. 

  1558.             if (has_bias)

  1559.             {

  1560.                 const onnx::TensorProto& B = weights[node.input(2)];

  1561.                 fwrite_tensor_proto_data(B, bp);

  1562.             }

  1563.         }

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

  1565.         {

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

  1567. 

  1568.             int has_bias = node.input_size() == 3 ? 1 : 0;

  1569. 

  1570.             std::string auto_pad = get_node_attr_s(node, "auto_pad");

  1571.             std::vector<int> kernel_shape = get_node_attr_ai(node, "kernel_shape");

  1572.             std::vector<int> dilations = get_node_attr_ai(node, "dilations");

  1573.             std::vector<int> strides = get_node_attr_ai(node, "strides");

  1574.             std::vector<int> output_padding = get_node_attr_ai(node, "output_padding");

  1575.             std::vector<int> output_shape = get_node_attr_ai(node, "output_shape");

  1576.             std::vector<int> pads = get_node_attr_ai(node, "pads");

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

  1578.             int num_filter = W.dims(1) * group;

  1579. 

  1580.             fprintf(pp, " 0=%d", num_filter);

  1581. 

  1582.             if (kernel_shape.size() == 1) {

  1583.                 fprintf(pp, " 1=%d", kernel_shape[0]);

  1584.             } else if (kernel_shape.size() == 2) {

  1585.                 fprintf(pp, " 1=%d", kernel_shape[1]);

  1586.                 fprintf(pp, " 11=%d", kernel_shape[0]);

  1587.             }

  1588. 

  1589.             if (dilations.size() == 1) {

  1590.                 fprintf(pp, " 2=%d", dilations[0]);

  1591.             } else if (dilations.size() == 2) {

  1592.                 fprintf(pp, " 2=%d", dilations[1]);

  1593.                 fprintf(pp, " 12=%d", dilations[0]);

  1594.             }

  1595. 

  1596.             if (strides.size() == 1) {

  1597.                 fprintf(pp, " 3=%d", strides[0]);

  1598.             } else if (strides.size() == 2) {

  1599.                 fprintf(pp, " 3=%d", strides[1]);

  1600.                 fprintf(pp, " 13=%d", strides[0]);

  1601.             }

  1602. 

  1603.             if (auto_pad == "SAME_UPPER")

  1604.             {

  1605.                 fprintf(pp, " 4=-233");

  1606.             }

  1607.             else if (auto_pad == "SAME_LOWER")

  1608.             {

  1609.                 fprintf(pp, " 4=-234");

  1610.             }

  1611.             else

  1612.             {

  1613. 

  1614.             if (pads.size() == 1) {

  1615.                 fprintf(pp, " 4=%d", pads[0]);

  1616.             } else if (pads.size() == 2) {

  1617.                 fprintf(pp, " 4=%d", pads[1]);

  1618.                 fprintf(pp, " 14=%d", pads[0]);

  1619.             } else if (pads.size() == 4) {

  1620.                 fprintf(pp, " 4=%d", pads[1]);

  1621.                 fprintf(pp, " 14=%d", pads[0]);

  1622.                 fprintf(pp, " 15=%d", pads[3]);

  1623.                 fprintf(pp, " 16=%d", pads[2]);

  1624.             }

  1625. 

  1626.             }

  1627. 

  1628.             if (output_padding.size() == 1) {

  1629.                 fprintf(pp, " 18=%d", output_padding[0]);

  1630.             } else if (output_padding.size() == 2) {

  1631.                 fprintf(pp, " 18=%d", output_padding[1]);

  1632.                 fprintf(pp, " 19=%d", output_padding[0]);

  1633.             }

  1634. 

  1635.             if (output_shape.size() == 1) {

  1636.                 fprintf(pp, " 20=%d", output_shape[0]);

  1637.             } else if (output_shape.size() == 2) {

  1638.                 fprintf(pp, " 20=%d", output_shape[1]);

  1639.                 fprintf(pp, " 21=%d", output_shape[0]);

  1640.             }

  1641. 

  1642.             fprintf(pp, " 5=%d", has_bias);

  1643. 

  1644.             fprintf(pp, " 6=%d", get_tensor_proto_data_size(W));

  1645. 

  1646.             if (group > 1) {

  1647.                 fprintf(pp, " 7=%d", group);

  1648.             }

  1649. 

  1650.             int quantize_tag = 0;

  1651.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  1652. 

  1653.             int maxk = 0;

  1654.             if (kernel_shape.size() == 2)

  1655.             {

  1656.                 maxk = kernel_shape[1] * kernel_shape[0];

  1657.             }

  1658.             else

  1659.             {

  1660.                 maxk = kernel_shape[0] * kernel_shape[0];

  1661.             }

  1662.             int weight_data_size = get_tensor_proto_data_size(W);

  1663.             const float* weight_data = 0;

  1664.             if (W.has_raw_data())

  1665.             {

  1666.                 weight_data = (const float*)W.raw_data().data();

  1667.             }

  1668.             else if (W.data_type() == 1)

  1669.             {

  1670.                 weight_data = W.float_data().data();

  1671.             }

  1672.             for (int g=0; g<group; g++)

  1673.             {

  1674.             // reorder weight from inch-outch to outch-inch

  1675.             int num_filter_g = num_filter / group;

  1676.             int num_input = weight_data_size / maxk / num_filter_g / group;

  1677.             const float* weight_data_ptr = weight_data + g * maxk * num_filter_g * num_input;

  1678.             for (int k=0; k<num_filter_g; k++)

  1679.             {

  1680.                 for (int j=0; j<num_input; j++)

  1681.                 {

  1682.                     fwrite(weight_data_ptr + (j*num_filter_g + k) * maxk, sizeof(float), maxk, bp);

  1683.                 }

  1684.             }

  1685.             }

  1686. 

  1687.             if (has_bias)

  1688.             {

  1689.                 const onnx::TensorProto& B = weights[node.input(2)];

  1690.                 fwrite_tensor_proto_data(B, bp);

  1691.             }

  1692.         }

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

  1694.         {

  1695.             int op_type = 10;

  1696.             fprintf(pp, " 0=%d", op_type);

  1697.         }

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

  1699.         {

  1700.             int op_type = 3;

  1701.             fprintf(pp, " 0=%d", op_type);

  1702.         }

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

  1704.         {

  1705.             // no-op

  1706.         }

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

  1708.         {

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

  1710.             fprintf(pp, " 0=%e", alpha);

  1711.         }

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

  1713.         {

  1714.             int op_type = 7;

  1715.             fprintf(pp, " 0=%d", op_type);

  1716.         }

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

  1718.         {

  1719.             int axis = get_node_attr_i(node, "axis", 1);

  1720.             if (axis != 1)

  1721.             {

  1722.                 fprintf(stderr, "Unsupported Flatten axis %d!\n", axis);

  1723.             }

  1724.         }

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

  1726.         {

  1727.             int op_type = 2;

  1728.             fprintf(pp, " 0=%d", op_type);

  1729.         }

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

  1731.         {

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

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

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

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

  1736. 

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

  1738.             {

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

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

  1741.                 {

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

  1743.                     const onnx::TensorProto& C = weights[node.input(2)];

  1744. 

  1745.                     fprintf(pp, " 0=%d", get_tensor_proto_data_size(C));

  1746.                     fprintf(pp, " 1=1");

  1747.                     fprintf(pp, " 2=%d", get_tensor_proto_data_size(B));

  1748. 

  1749.                     int quantize_tag = 0;

  1750.                     fwrite(&quantize_tag, sizeof(int), 1, bp);

  1751. 

  1752.                     fwrite_tensor_proto_data(B, bp);

  1753.                     fwrite_tensor_proto_data(C, bp);

  1754.                 }

  1755.             }

  1756.         }

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

  1758.         {

  1759.             int pool = 1;

  1760.             int global_pool = 1;

  1761. 

  1762.             fprintf(pp, " 0=%d", pool);

  1763.             fprintf(pp, " 4=%d", global_pool);

  1764.         }

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

  1766.         {

  1767.             int pool = 0;

  1768.             int global_pool = 1;

  1769. 

  1770.             fprintf(pp, " 0=%d", pool);

  1771.             fprintf(pp, " 4=%d", global_pool);

  1772.         }

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

  1774.         {

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

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

  1777. 

  1778.             fprintf(pp, " 0=%e", alpha);

  1779.             fprintf(pp, " 1=%e", beta);

  1780.         }

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

  1782.         {

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

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

  1785. 

  1786.             fprintf(pp, " 0=%e", alpha);

  1787.             fprintf(pp, " 1=%e", beta);

  1788.         }

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

  1790.         {

  1791.             std::vector<float> bias = get_node_attr_af(node, "bias");

  1792.             float scale = get_node_attr_f(node, "scale", 1.f);

  1793. 

  1794.             int channels = bias.size();

  1795. 

  1796.             fprintf(pp, " 0=%d", channels);

  1797.             fprintf(pp, " 1=1");

  1798. 

  1799.             for (int j=0; j<channels; j++)

  1800.             {

  1801.                 fwrite(&scale, sizeof(float), 1, bp);

  1802.             }

  1803.             fwrite(&bias[0], sizeof(float), channels, bp);

  1804.         }

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

  1806.         {

  1807.             float eps = get_node_attr_f(node, "epsilon", 1e-5f);

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

  1809.             const onnx::TensorProto& B = weights[node.input(2)];

  1810.             int channels = get_tensor_proto_data_size(scale);

  1811. 

  1812.             fprintf(pp, " 0=%d", channels);

  1813.             fprintf(pp, " 1=%e", eps);

  1814.             fwrite_tensor_proto_data(scale, bp);

  1815.             fwrite_tensor_proto_data(B, bp);

  1816.         }

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

  1818.         {

  1819.             float alpha = get_node_attr_f(node, "alpha", 0.01f);

  1820. 

  1821.             fprintf(pp, " 0=%e", alpha);

  1822.         }

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

  1824.         {

  1825.             int op_type = 8;

  1826.             fprintf(pp, " 0=%d", op_type);

  1827.         }

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

  1829.         {

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

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

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

  1833.             int size = get_node_attr_i(node, "size", 1);

  1834. 

  1835.             int norm_region = 0;

  1836. 

  1837.             fprintf(pp, " 0=%d", norm_region);

  1838.             fprintf(pp, " 1=%d", size);

  1839.             fprintf(pp, " 2=%e", alpha);

  1840.             fprintf(pp, " 3=%e", beta);

  1841.             fprintf(pp, " 4=%e", bias);

  1842.         }

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

  1844.         {

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

  1846. 

  1847.             int weight_data_size = get_tensor_proto_data_size(B);

  1848. 

  1849.             int num_output = B.dims(B.dims_size()-1);

  1850.             int num_input = weight_data_size / num_output;

  1851. 

  1852.             fprintf(pp, " 0=%d", num_output);

  1853.             fprintf(pp, " 1=0");

  1854.             fprintf(pp, " 2=%d", weight_data_size);

  1855. 

  1856.             int quantize_tag = 0;

  1857.             fwrite(&quantize_tag, sizeof(int), 1, bp);

  1858. 

  1859.             // reorder num_input-num_output to num_output-num_input

  1860.             {

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

  1862. 

  1863.                 for (int j=0; j<num_output; j++)

  1864.                 {

  1865.                     for (int k=0; k<num_input; k++)

  1866.                     {

  1867.                         float vb = bptr[ k*num_output + j ];

  1868.                         fwrite(&vb, sizeof(float), 1, bp);

  1869.                     }

  1870.                 }

  1871.             }

  1872. 

  1873. //                 fwrite_tensor_proto_data(B, bp)

  1874.         }

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

  1876.         {

  1877.             int op_type = 4;

  1878.             fprintf(pp, " 0=%d", op_type);

  1879.         }

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

  1881.         {

  1882.             int op_type = 5;

  1883.             fprintf(pp, " 0=%d", op_type);

  1884.         }

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

  1886.         {

  1887.             int op_type = 2;

  1888.             fprintf(pp, " 0=%d", op_type);

  1889.         }

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

  1891.         {

  1892.             int op_type = 1;

  1893.             fprintf(pp, " 0=%d", op_type);

  1894.         }

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

  1896.         {

  1897.             std::string mode = get_node_attr_s(node, "mode");

  1898.             std::vector<int> pads = get_node_attr_ai(node, "pads");

  1899.             float value = get_node_attr_f(node, "value", 0.f);

  1900. 

  1901.             int type = 0;

  1902.             if (mode == "constant")

  1903.             {

  1904.                 type = 0;

  1905.             }

  1906.             else if (mode == "edge")

  1907.             {

  1908.                 type = 1;

  1909.             }

  1910.             else if (mode == "reflect")

  1911.             {

  1912.                 type = 2;

  1913.             }

  1914. 

  1915.             int pad_size = pads.size();

  1916.             int top, bottom, left, right;

  1917.             if (pad_size == 8)

  1918.             {

  1919.                 //NCHW

  1920.                 top = pads[2];

  1921.                 bottom = pads[6];

  1922.                 left = pads[3];

  1923.                 right = pads[7];

  1924.             }

  1925.             else if (pad_size == 6)

  1926.             {

  1927.                 //CHW

  1928.                 top = pads[1];

  1929.                 bottom = pads[4];

  1930.                 left = pads[2];

  1931.                 right = pads[5];

  1932.             }

  1933.             else

  1934.             {

  1935.                 //HW

  1936.                 top = pads[0];

  1937.                 bottom = pads[2];

  1938.                 left = pads[1];

  1939.                 right = pads[3];

  1940.             }

  1941. 

  1942.             fprintf(pp, " 0=%d", top);

  1943.             fprintf(pp, " 1=%d", bottom);

  1944.             fprintf(pp, " 2=%d", left);

  1945.             fprintf(pp, " 3=%d", right);

  1946.             fprintf(pp, " 4=%d", type);

  1947.             fprintf(pp, " 5=%e", value);

  1948.         }

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

  1950.         {

  1951.             int op_type = 6;

  1952.             fprintf(pp, " 0=%d", op_type);

  1953.         }

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

  1955.         {

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

  1957. 

  1958.             int num_slope = get_tensor_proto_data_size(slope);

  1959. 

  1960.             fprintf(pp, " 0=%d", num_slope);

  1961. 

  1962.             fwrite_tensor_proto_data(slope, bp);

  1963.         }

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

  1965.         {

  1966.             int op_type = 15;

  1967.             fprintf(pp, " 0=%d", op_type);

  1968.         }

  1969.         else if (op == "ReduceMax" || op == "ReduceMin" || op == "ReduceMean" ||

  1970.                 op == "ReduceProd" || op == "ReduceSum" || op == "ReduceSumSquare" ||

  1971.                 op == "ReduceL1" || op == "ReduceL2" || op == "ReduceLogSum" || op == "ReduceLogSumExp")

  1972.         {

  1973.             int op_type = -233;

  1974.             if (op == "ReduceSum")

  1975.                 op_type = 0;

  1976.             else if (op == "ReduceSumSquare")

  1977.                 op_type = 2;

  1978.             else if (op == "ReduceMean")

  1979.                 op_type = 3;

  1980.             else if (op == "ReduceMax")

  1981.                 op_type = 4;

  1982.             else if (op == "ReduceMin")

  1983.                 op_type = 5;

  1984.             else if (op == "ReduceProd")

  1985.                 op_type = 6;

  1986.             else if (op == "ReduceL1")

  1987.                 op_type = 7;

  1988.             else if (op == "ReduceL2")

  1989.                 op_type = 8;

  1990.             else if (op == "ReduceLogSum")

  1991.                 op_type = 9;

  1992.             else if (op == "ReduceLogSumExp")

  1993.                 op_type = 10;

  1994.             fprintf(pp, " 0=%d", op_type);

  1995. 

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

  1997.             int keepdims = get_node_attr_i(node, "keepdims", 1);

  1998.             

  1999.             if (axes.size() > 0)

  2000.             {

  2001.                 // if axes set, reduce according to axes

  2002.                 fprintf(pp, " 1=%d", 0); 

  2003.                 fprintf(pp, " -23303=%d", axes.size());

  2004.                 for (int i=0; i< axes.size(); i++)

  2005.                 {

  2006.                     if (axes[i] == 0 || axes[i] > 3 || axes[i] < -3)

  2007.                         fprintf(stderr, "Unsupported reduction axes !\n");

  2008.                     fprintf(pp, ",%d", axes[i]);

  2009.                 }

  2010.             }

  2011.             else

  2012.             {

  2013.                 // if axes not set, reduce all axes by default

  2014.                 fprintf(pp, " 1=%d", 1);

  2015.             }

  2016.             fprintf(pp, " 4=%d", keepdims);

  2017.         }

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

  2019.         {

  2020.             std::vector<int> shape;

  2021. 

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

  2023.             {

  2024.                 shape = get_node_attr_ai(node, "shape");

  2025.             }

  2026.             else

  2027.             {

  2028.                 shape = get_tensor_proto_reshape_shape(weights[node.input(1)]);

  2029.             }

  2030. 

  2031.             if (shape.size() == 1) {

  2032.                 fprintf(pp, " 0=%d", shape[0]);// should never reach here

  2033.             } else if (shape.size() == 2) {

  2034.                 fprintf(pp, " 0=%d", shape[1]);

  2035.             } else if (shape.size() == 3) {

  2036.                 fprintf(pp, " 0=%d", shape[2]);

  2037.                 fprintf(pp, " 1=%d", shape[1]);

  2038.             } else if (shape.size() == 4) {

  2039.                 fprintf(pp, " 0=%d", shape[3]);

  2040.                 fprintf(pp, " 1=%d", shape[2]);

  2041.                 fprintf(pp, " 2=%d", shape[1]);

  2042.             } else if (shape.size() == 5) {

  2043.                 fprintf(pp, " 0=%d", shape[4] * shape[3]);

  2044.                 fprintf(pp, " 1=%d", shape[2]);

  2045.                 fprintf(pp, " 2=%d", shape[1]);

  2046.             }

  2047.         }

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

  2049.         {

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

  2051.             fprintf(pp, " 0=%d", group);

  2052.         }

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

  2054.         {

  2055.         }

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

  2057.         {

  2058.             int op_type = 9;

  2059.             fprintf(pp, " 0=%d", op_type);

  2060.         }

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

  2062.         {

  2063.             std::vector<int> starts = get_node_attr_ai(node, "starts");

  2064.             std::vector<int> ends = get_node_attr_ai(node, "ends");

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

  2066.             std::vector<int> steps = get_node_attr_ai(node, "steps");// TODO

  2067. 

  2068.             // assert step == 1

  2069.             for (int i=0; i<(int)steps.size(); i++)

  2070.             {

  2071.                 if (steps[i] != 1)

  2072.                     fprintf(stderr, "Unsupported slice step !\n");

  2073.             }

  2074. 

  2075.             fprintf(pp, " -23309=%d", starts.size());

  2076.             for (int i=0; i<(int)starts.size(); i++)

  2077.             {

  2078.                 fprintf(pp, ",%d", starts[i]);

  2079.             }

  2080.             fprintf(pp, " -23310=%d", ends.size());

  2081.             for (int i=0; i<(int)ends.size(); i++)

  2082.             {

  2083.                 fprintf(pp, ",%d", ends[i]);

  2084.             }

  2085.             if (!axes.empty())

  2086.             {

  2087.                 fprintf(pp, " -23311=%d", axes.size());

  2088.                 for (int i=0; i<(int)axes.size(); i++)

  2089.                 {

  2090.                     if (axes[i] == 0 || axes[i] > 3 || axes[i] < -3)

  2091.                         fprintf(stderr, "Unsupported reduction axes !\n");

  2092.                     fprintf(pp, ",%d", axes[i]);

  2093.                 }

  2094.             }

  2095.         }

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

  2097.         {

  2098.             int axis = get_node_attr_i(node, "axis", 1);

  2099.             fprintf(pp, " 0=%d", axis-1);

  2100.             fprintf(pp, " 1=1");

  2101.         }

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

  2103.         {

  2104.             int axis = get_node_attr_i(node, "axis", 0);

  2105.             std::vector<int> split = get_node_attr_ai(node, "split");

  2106.             if (axis < 1)

  2107.                 fprintf(stderr, "Unsupported split axis !\n");

  2108. 

  2109.             fprintf(pp, " -23300=%d", output_size);

  2110.             if (split.empty())

  2111.             {

  2112.                 for (int i=0; i<output_size; i++)

  2113.                 {

  2114.                     fprintf(pp, ",-233");

  2115.                 }

  2116.             }

  2117.             else

  2118.             {

  2119.                 for (int i=0; i<split.size() - 1; i++)

  2120.                 {

  2121.                     fprintf(pp, ",%d", split[i]);

  2122.                 }

  2123.                 fprintf(pp, ",-233");

  2124.             }

  2125.             fprintf(pp, " 1=%d", axis - 1);

  2126.         }

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

  2128.         {

  2129.             int op_type = 5;

  2130.             fprintf(pp, " 0=%d", op_type);

  2131.         }

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

  2133.         {

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

  2135. 

  2136.             if (axes.empty())

  2137.             {

  2138.                 fprintf(pp, " 0=1");

  2139.                 fprintf(pp, " 1=1");

  2140.                 fprintf(pp, " 2=1");

  2141.             }

  2142.             else

  2143.             {

  2144.                 fprintf(pp, " -23303=%d", axes.size());

  2145.                 for (int i=0; i<(int)axes.size(); i++)

  2146.                 {

  2147.                     if (axes[i] == 0 || axes[i] > 3 || axes[i] < -3)

  2148.                         fprintf(stderr, "Unsupported squeeze axes !\n");

  2149.                     fprintf(pp, ",%d", axes[i]);

  2150.                 }

  2151.             }

  2152.         }

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

  2154.         {

  2155.             int op_type = 1;

  2156.             fprintf(pp, " 0=%d", op_type);

  2157.         }

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

  2159.         {

  2160.             int op_type = 1;

  2161.             fprintf(pp, " 0=%d", op_type);

  2162.         }

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

  2164.         {

  2165.             int op_type = 11;

  2166.             fprintf(pp, " 0=%d", op_type);

  2167.         }

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

  2169.         {

  2170.             int op_type = 16;

  2171.             fprintf(pp, " 0=%d", op_type);

  2172.         }

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

  2174.         {

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

  2176. 

  2177.             if (perm.size() == 4) {

  2178.                 if (perm[1] == 1 && perm[2] == 2 && perm[3] == 3)

  2179.                     fprintf(pp, " 0=0");// w h c

  2180.                 else if (perm[1] == 1 && perm[2] == 3 && perm[3] == 2)

  2181.                     fprintf(pp, " 0=1");// h w c

  2182.                 else if (perm[1] == 2 && perm[2] == 1 && perm[3] == 3)

  2183.                     fprintf(pp, " 0=2");// w c h

  2184.                 else if (perm[1] == 2 && perm[2] == 3 && perm[3] == 1)

  2185.                     fprintf(pp, " 0=3");// c w h

  2186.                 else if (perm[1] == 3 && perm[2] == 1 && perm[3] == 2)

  2187.                     fprintf(pp, " 0=4");// h c w

  2188.                 else if (perm[1] == 3 && perm[2] == 2 && perm[3] == 1)

  2189.                     fprintf(pp, " 0=5");// c h w

  2190.             } else if (perm.size() == 5) {

  2191.                 if (perm[1] == 1 && perm[2] == 2 && perm[3] == 3 && perm[4] == 4)

  2192.                     fprintf(pp, " 0=0");// wx h c

  2193.                 else if (perm[1] == 1 && perm[2] == 3 && perm[3] == 4 && perm[4] == 2)

  2194.                     fprintf(pp, " 0=1");// h wx c

  2195.                 else if (perm[1] == 2 && perm[2] == 1 && perm[3] == 3 && perm[4] == 4)

  2196.                     fprintf(pp, " 0=2");// wx c h

  2197.                 else if (perm[1] == 2 && perm[2] == 3 && perm[3] == 4 && perm[4] == 1)

  2198.                     fprintf(pp, " 0=3");// c wx h

  2199.                 else if (perm[1] == 3 && perm[2] == 4 && perm[3] == 1 && perm[4] == 2)

  2200.                     fprintf(pp, " 0=4");// h c wx

  2201.                 else if (perm[1] == 3 && perm[2] == 4 && perm[3] == 2 && perm[4] == 1)

  2202.                     fprintf(pp, " 0=5");// c h wx

  2203.                 else

  2204.                     fprintf(stderr, "Unsupported transpose type !\n");

  2205.             }

  2206.         }

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

  2208.         {

  2209.             std::string mode = get_node_attr_s(node, "mode");

  2210. 

  2211.             std::vector<float> scales;

  2212. 

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

  2214.             {

  2215.                 scales = get_node_attr_af(node, "scales");

  2216.             }

  2217.             else

  2218.             {

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

  2220.                 const float* shape_data = scales_tp.has_raw_data() ? (const float*)scales_tp.raw_data().data() : scales_tp.float_data().data();

  2221.                 

  2222.                 int float_data_size = scales_tp.float_data_size();

  2223.                 //float data is None, use raw data instead

  2224.                 if (float_data_size == 0) {

  2225.                     float_data_size = scales_tp.dims().Get(0);

  2226.                 }

  2227. 

  2228.                 for (int j=0; j<float_data_size; j++)

  2229.                 {

  2230.                     scales.push_back(shape_data[j]);

  2231.                 }

  2232.             }

  2233. 

  2234.             int resize_type = 1;

  2235.             if (mode == "nearest")

  2236.             {

  2237.                 resize_type = 1;

  2238.             }

  2239.             else if (mode == "bilinear" || mode == "linear")

  2240.             {

  2241.                 resize_type = 2;

  2242.             }

  2243.             else if (mode == "trilinear")

  2244.             {

  2245.                 fprintf(stderr, "Unsupported Upsample/Resize mode !\n");

  2246.             }

  2247. 

  2248.             float h_scale = 1.f;

  2249.             float w_scale = 1.f;

  2250.             if (scales.size() == 2)

  2251.             {

  2252.                 w_scale = scales[1];

  2253.             }

  2254.             else if (scales.size() == 3)

  2255.             {

  2256.                 h_scale = scales[1];

  2257.                 w_scale = scales[2];

  2258.             }

  2259.             else if (scales.size() == 4)

  2260.             {

  2261.                 h_scale = scales[2];

  2262.                 w_scale = scales[3];

  2263. 

  2264.                 if (scales[1] != 1.f)

  2265.                     fprintf(stderr, "Unsupported Upsample/Resize scales !\n");

  2266.             }

  2267.             else

  2268.             {

  2269.                 fprintf(stderr, "Unsupported Upsample/Resize scales !\n");

  2270.             }

  2271. 

  2272.             fprintf(pp, " 0=%d", resize_type);

  2273.             fprintf(pp, " 1=%e", h_scale);

  2274.             fprintf(pp, " 2=%e", w_scale);

  2275.         }

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

  2277.         {

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

  2279. 

  2280.             fprintf(pp, " -23303=%d", axes.size());

  2281.             for (int i=0; i<(int)axes.size(); i++)

  2282.             {

  2283.                 if (axes[i] == 0 || axes[i] > 4 || axes[i] < -4)

  2284.                     fprintf(stderr, "Unsupported unsqueeze axes !\n");

  2285.                 fprintf(pp, ",%d", axes[i]);

  2286.             }

  2287.         }

  2288.         else

  2289.         {

  2290.             // TODO op specific param

  2291.             for (int j=0; j<node.attribute_size(); j++)

  2292.             {

  2293.                 const onnx::AttributeProto& attr = node.attribute(j);

  2294.                 if (attr.type() == 1)

  2295.                 {

  2296.                     fprintf(stderr, "  # %s=%g\n", attr.name().c_str(), attr.f());

  2297.                 }

  2298.                 else if (attr.type() == 2)

  2299.                 {

  2300.                     fprintf(stderr, "  # %s=%ld\n", attr.name().c_str(), attr.i());

  2301.                 }

  2302.                 else if (attr.type() == 3)

  2303.                 {

  2304.                     fprintf(stderr, "  # %s=%s\n", attr.name().c_str(), attr.s().c_str());

  2305.                 }

  2306.                 else

  2307.                 {

  2308.                     fprintf(stderr, "  # %s %d\n", attr.name().c_str(), attr.type());

  2309.                 }

  2310.             }

  2311.         }

  2312. 

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

  2314. 

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

  2316.         {

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

  2318.             if (node_reference.find(output_name) != node_reference.end())

  2319.             {

  2320.                 int refcount = node_reference[output_name];

  2321.                 if (refcount > 1)

  2322.                 {

  2323.                     char splitname[256];

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

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

  2326. 

  2327.                     fprintf(pp, " %s", output_name.c_str());

  2328. 

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

  2330.                     {

  2331.                         fprintf(pp, " %s_splitncnn_%d", output_name.c_str(), k);

  2332.                     }

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

  2334. 

  2335.                     internal_split++;

  2336.                 }

  2337.             }

  2338.         }

  2339.     }

  2340. 

  2341.     fclose(pp);

  2342.     fclose(bp);

  2343. 

  2344.     return 0;

  2345. }