hummingbird
/
graphengine
Not watched
2
0
Fork 0
Code
Releases 13 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
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: dc72f5dcae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc72f5dcae'
${ noResults }
graphengine/metadef/graph/utils/ge_ir_utils.cc

1179 lines
51 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2019-2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

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

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include "graph/utils/ge_ir_utils.h"

  18. #include <utility>

  19. #include "framework/common/debug/ge_log.h"

  20. 

  21. namespace {

  22. const char *const kControlAnchorIndex = ":-1";

  23. const char *const kNodeTypeForSubgraph = "subgraph";

  24. const char *const kPrefixForInputDesc = "input_desc_attr_";

  25. const char *const kPrefixForOutputDesc = "output_desc_attr_";

  26. const char *const kDumpGEGraph = "DUMP_GE_GRAPH";

  27. const int8_t kMaxRecursionDepth = 10;

  28. const char *const kDumpGeGraph = std::getenv(kDumpGEGraph);

  29. const int64_t kDumpLevel = (kDumpGeGraph != nullptr) ? std::strtol(kDumpGeGraph, nullptr, 10) : ge::OnnxUtils::NO_DUMP;

  30. const int64_t kInputPrefixLength = 5;

  31. const int64_t kOutputPrefixLength = 6;

  32. using AttrDefPair = ::google::protobuf::MapPair<std::string, ge::proto::AttrDef>;

  33. }  // namespace

  34. 

  35. namespace ge {

  36. // Part 1: from IR convert to ONNX Protobuf

  37. static const std::map<ge::DataType, onnx::TensorProto_DataType> kGeDataTypeToOnnxMap = {

  38.   {DT_INT64, onnx::TensorProto_DataType_INT64},   {DT_UINT64, onnx::TensorProto_DataType_UINT64},

  39.   {DT_FLOAT, onnx::TensorProto_DataType_FLOAT},   {DT_INT32, onnx::TensorProto_DataType_INT32},

  40.   {DT_UINT32, onnx::TensorProto_DataType_UINT32}, {DT_INT8, onnx::TensorProto_DataType_INT8},

  41.   {DT_UINT8, onnx::TensorProto_DataType_UINT8},   {DT_INT16, onnx::TensorProto_DataType_INT16},

  42.   {DT_UINT16, onnx::TensorProto_DataType_UINT16}, {DT_FLOAT16, onnx::TensorProto_DataType_FLOAT16},

  43.   {DT_DOUBLE, onnx::TensorProto_DataType_DOUBLE}, {DT_BOOL, onnx::TensorProto_DataType_BOOL},

  44. };

  45. 

  46. onnx::TensorProto_DataType OnnxUtils::EncodeDataType(DataType data_type) {

  47.   auto it = kGeDataTypeToOnnxMap.find(data_type);

  48.   if (it != kGeDataTypeToOnnxMap.end()) {

  49.     return it->second;

  50.   } else {

  51.     GELOGW("EncodeDataType: datatype not support %u", data_type);

  52.     return onnx::TensorProto_DataType_UNDEFINED;

  53.   }

  54. }

  55. 

  56. void OnnxUtils::AddAttrProtoFromAttribute(const std::pair<const std::string, ge::GeAttrValue> &string_attr_value,

  57.                                           onnx::NodeProto *node_proto) {

  58.   if (node_proto == nullptr) {

  59.     GELOGE(FAILED, "Node proto is nullptr.");

  60.     return;

  61.   }

  62.   auto attr = node_proto->add_attribute();

  63.   if (attr == nullptr) {

  64.     GELOGE(GRAPH_FAILED, "attr is nullptr.");

  65.     return;

  66.   }

  67.   auto attr_name = string_attr_value.first;

  68.   attr->set_name(attr_name);

  69.   auto attr_value = string_attr_value.second;

  70.   auto value_type = attr_value.GetValueType();

  71.   switch (value_type) {

  72.     case GeAttrValue::VT_FLOAT: {

  73.       GeAttrValue::FLOAT data_f = 0;

  74.       (void)attr_value.GetValue(data_f);

  75.       attr->set_f(data_f);

  76.       attr->set_type(onnx::AttributeProto_AttributeType_FLOAT);

  77.       break;

  78.     }

  79.     case GeAttrValue::VT_LIST_FLOAT: {

  80.       GeAttrValue::LIST_FLOAT data_fs = {};

  81.       (void)attr_value.GetValue(data_fs);

  82.       attr->set_type(onnx::AttributeProto_AttributeType_FLOATS);

  83.       for (auto &v : data_fs) {

  84.         attr->add_floats(v);

  85.       }

  86.       break;

  87.     }

  88.     case GeAttrValue::VT_INT: {

  89.       GeAttrValue::INT data_i = 0;

  90.       (void)attr_value.GetValue(data_i);

  91.       attr->set_type(onnx::AttributeProto_AttributeType_INT);

  92.       attr->set_i(data_i);

  93.       break;

  94.     }

  95.     case GeAttrValue::VT_LIST_INT: {

  96.       GeAttrValue::LIST_INT data_is = {};

  97.       (void)attr_value.GetValue(data_is);

  98.       attr->set_type(onnx::AttributeProto_AttributeType_INTS);

  99.       for (auto &v : data_is) {

  100.         attr->add_ints(v);

  101.       }

  102.       break;

  103.     }

  104.     case GeAttrValue::VT_STRING: {

  105.       GeAttrValue::STR data_s;

  106.       (void)attr_value.GetValue(data_s);

  107.       attr->set_type(onnx::AttributeProto_AttributeType_STRING);

  108.       attr->set_s(data_s);

  109.       break;

  110.     }

  111.     case GeAttrValue::VT_LIST_STRING: {

  112.       GeAttrValue::LIST_STR data_ss = {};

  113.       (void)attr_value.GetValue(data_ss);

  114.       attr->set_type(onnx::AttributeProto_AttributeType_STRINGS);

  115.       for (auto &v : data_ss) {

  116.         attr->add_strings(v);

  117.       }

  118.       break;

  119.     }

  120.     default:

  121.       GELOGW("GeAttrValue ValueType: %u is not supported for now", value_type);

  122.       break;

  123.   }

  124. }

  125. 

  126. void OnnxUtils::AddAttrProto(onnx::NodeProto *node_proto, onnx::AttributeProto_AttributeType type, const string &name,

  127.                              void *data) {

  128.   if (node_proto == nullptr) {

  129.     GELOGE(FAILED, "Node_proto %s is nullptr.", name.c_str());

  130.     return;

  131.   }

  132.   auto attr = node_proto->add_attribute();

  133.   if (attr == nullptr) {

  134.     GELOGE(GRAPH_FAILED, "attr is nullptr.");

  135.     return;

  136.   }

  137.   attr->set_name(name);

  138.   switch (type) {

  139.     case onnx::AttributeProto_AttributeType_FLOAT:

  140.       attr->set_f((*(static_cast<float *>(data))));

  141.       attr->set_type(onnx::AttributeProto_AttributeType_FLOAT);

  142.       break;

  143. 

  144.     case onnx::AttributeProto_AttributeType_FLOATS:

  145.       attr->set_type(onnx::AttributeProto_AttributeType_FLOATS);

  146.       for (auto &v : (*(static_cast<std::vector<float> *>(data)))) {

  147.         attr->add_floats(v);

  148.       }

  149.       break;

  150. 

  151.     case onnx::AttributeProto_AttributeType_INT:

  152.       attr->set_type(onnx::AttributeProto_AttributeType_INT);

  153.       attr->set_i((*(static_cast<int64_t *>(data))));

  154.       break;

  155. 

  156.     case onnx::AttributeProto_AttributeType_INTS:

  157.       attr->set_type(onnx::AttributeProto_AttributeType_INTS);

  158.       for (auto &v : *(static_cast<std::vector<int64_t> *>(data))) {

  159.         attr->add_ints(v);

  160.       }

  161.       break;

  162. 

  163.     case onnx::AttributeProto_AttributeType_STRING:

  164.       attr->set_type(onnx::AttributeProto_AttributeType_STRING);

  165.       attr->set_s((*(static_cast<std::string *>(data))));

  166.       break;

  167. 

  168.     case onnx::AttributeProto_AttributeType_STRINGS:

  169.       attr->set_type(onnx::AttributeProto_AttributeType_STRINGS);

  170.       for (auto &v : *(static_cast<std::vector<std::string> *>(data))) {

  171.         attr->add_strings(v);

  172.       }

  173.       break;

  174. 

  175.     default:

  176.       GELOGW("AttributeProto AttributeType: %u is not supported for now", type);

  177.       break;

  178.   }

  179. }

  180. 

  181. void OnnxUtils::AddAttrProto(onnx::NodeProto *node_proto, onnx::AttributeProto_AttributeType type, const string &name,

  182.                              ::google::protobuf::RepeatedField<::google::protobuf::int64> data) {

  183.   if (node_proto == nullptr) {

  184.     GELOGE(FAILED, "Node_proto %s is nullptr.", name.c_str());

  185.     return;

  186.   }

  187.   if (!data.empty()) {

  188.     auto attr = node_proto->add_attribute();

  189.     if (attr == nullptr) {

  190.       GELOGE(GRAPH_FAILED, "attr is nullptr.");

  191.       return;

  192.     }

  193.     attr->set_name(name);

  194.     for (auto &v : data) {

  195.       attr->add_ints(v);

  196.     }

  197.     attr->set_type(type);

  198.   }

  199. }

  200. 

  201. void OnnxUtils::AddAttrProto(onnx::NodeProto *node_proto, onnx::AttributeProto_AttributeType type, const string &name,

  202.                              ::google::protobuf::RepeatedField<bool> data) {

  203.   if (node_proto == nullptr) {

  204.     GELOGE(FAILED, "Node proto %s is nullptr.", name.c_str());

  205.     return;

  206.   }

  207.   if (!data.empty()) {

  208.     auto attr = node_proto->add_attribute();

  209.     if (attr == nullptr) {

  210.       GELOGE(GRAPH_FAILED, "attr is nullptr.");

  211.       return;

  212.     }

  213.     attr->set_name(name);

  214.     for (auto &v : data) {

  215.       attr->add_ints(static_cast<int64_t>(v));

  216.     }

  217.     attr->set_type(type);

  218.   }

  219. }

  220. 

  221. void OnnxUtils::AddAttrProto(onnx::NodeProto *node_proto, onnx::AttributeProto_AttributeType type, const string &name,

  222.                              ::google::protobuf::RepeatedField<float> data) {

  223.   if (node_proto == nullptr) {

  224.     GELOGE(FAILED, "Node_proto %s is nullptr.", name.c_str());

  225.     return;

  226.   }

  227.   if (!data.empty()) {

  228.     auto attr = node_proto->add_attribute();

  229.     if (attr == nullptr) {

  230.       GELOGE(GRAPH_FAILED, "attr is nullptr.");

  231.       return;

  232.     }

  233.     attr->set_name(name);

  234.     for (auto &v : data) {

  235.       attr->add_floats(v);

  236.     }

  237.     attr->set_type(type);

  238.   }

  239. }

  240. 

  241. void OnnxUtils::AddAttrProto(onnx::NodeProto *node_proto, onnx::AttributeProto_AttributeType type, const string &name,

  242.                              ::google::protobuf::RepeatedPtrField<::std::string> data) {

  243.   if (node_proto == nullptr) {

  244.     GELOGE(FAILED, "Node proto %s is nullptr.", name.c_str());

  245.     return;

  246.   }

  247.   if (!data.empty()) {

  248.     auto attr = node_proto->add_attribute();

  249.     if (attr == nullptr) {

  250.       GELOGE(GRAPH_FAILED, "attr is nullptr.");

  251.       return;

  252.     }

  253.     attr->set_name(name);

  254.     for (auto &v : data) {

  255.       attr->add_strings(v);

  256.     }

  257.     attr->set_type(type);

  258.   }

  259. }

  260. 

  261. void OnnxUtils::AddAttrProtoForOpInAndOutDesc(onnx::NodeProto *node_proto, const OpDescPtr &op_desc) {

  262.   if (node_proto == nullptr || op_desc == nullptr) {

  263.     GELOGE(GRAPH_FAILED, "node_proto or op_desc is nullptr");

  264.     return;

  265.   }

  266.   // Input describes

  267.   auto size_in = op_desc->GetAllInputsSize();

  268.   AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "input_desc_nums", &size_in);

  269.   if (size_in > 0) {

  270.     for (uint32_t i = 0; i < size_in; i++) {

  271.       auto input_desc = op_desc->GetInputDescPtrDfault(i);

  272.       if (input_desc != nullptr) {

  273.         auto data_type = TypeUtils::DataTypeToSerialString(input_desc->GetDataType());

  274.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, "input_desc_dtype:" + std::to_string(i),

  275.                      &data_type);

  276.         auto data_type_origin = TypeUtils::DataTypeToSerialString(input_desc->GetOriginDataType());

  277.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  278.                      "input_desc_origin_dtype:" + std::to_string(i), &data_type_origin);

  279.         auto dims = input_desc->GetShape().GetDims();

  280.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "input_desc_shape:" + std::to_string(i),

  281.                      &dims);

  282.         auto dims_origin = input_desc->GetOriginShape().GetDims();

  283.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS,

  284.                      "input_desc_origin_shape:" + std::to_string(i), &dims_origin);

  285.         auto layout = TypeUtils::FormatToSerialString(input_desc->GetFormat());

  286.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, "input_desc_layout:" + std::to_string(i),

  287.                      &layout);

  288.         auto layout_origin = TypeUtils::FormatToSerialString(input_desc->GetOriginFormat());

  289.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  290.                      "input_desc_origin_layout:" + std::to_string(i), &layout_origin);

  291.         auto tensor_descriptor = input_desc->tensor_descriptor_.GetProtoMsg();

  292.         if (tensor_descriptor != nullptr) {

  293.           auto size = tensor_descriptor->size();

  294.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "input_desc_size:" + std::to_string(i),

  295.                        &size);

  296.           auto weight_size = tensor_descriptor->weight_size();

  297.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  298.                        "input_desc_weight_size:" + std::to_string(i), &weight_size);

  299.           auto reuse_input = tensor_descriptor->reuse_input();

  300.           auto reuse_input_int = static_cast<int64_t>(reuse_input);

  301.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  302.                        "input_desc_reuse_input:" + std::to_string(i), &reuse_input_int);

  303.           auto output_tensor = tensor_descriptor->output_tensor();

  304.           auto output_tensor_int = static_cast<int64_t>(output_tensor);

  305.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  306.                        "input_desc_output_tensor:" + std::to_string(i), &output_tensor_int);

  307.           auto device_type = tensor_descriptor->device_type();

  308.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  309.                        "input_desc_device_type:" + std::to_string(i), &device_type);

  310.           auto input_tensor = tensor_descriptor->input_tensor();

  311.           auto input_tensor_int = static_cast<int64_t>(input_tensor);

  312.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  313.                        "input_desc_input_tensor:" + std::to_string(i), &input_tensor_int);

  314.           auto real_dim_cnt = tensor_descriptor->real_dim_cnt();

  315.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  316.                        "input_desc_real_dim_cnt:" + std::to_string(i), &real_dim_cnt);

  317.           auto data_offset = tensor_descriptor->data_offset();

  318.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  319.                        "input_desc_data_offset:" + std::to_string(i), &data_offset);

  320.           auto cmps_size = tensor_descriptor->cmps_size();

  321.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "input_desc_cmps_size:" + std::to_string(i),

  322.                        &cmps_size);

  323.           auto cmps_tab = tensor_descriptor->cmps_tab();

  324.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  325.                        "input_desc_cmps_tab:" + std::to_string(i), &cmps_tab);

  326.           auto cmps_tab_offset = tensor_descriptor->cmps_tab_offset();

  327.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  328.                        "input_desc_cmps_tab_offset:" + std::to_string(i), &cmps_tab_offset);

  329.           const auto &tensor_desc_map = tensor_descriptor->attr();

  330.           std::string suffix = ":" + std::to_string(i);

  331.           AddAttrProtoForAttrsFromAttrMap(tensor_desc_map, node_proto, kPrefixForInputDesc, suffix);

  332.         } else {

  333.           GELOGW("Tensor descriptor is nullptr");

  334.           continue;

  335.         }

  336.       } else {

  337.         GELOGW("Input desc is nullptr");

  338.         continue;

  339.       }

  340.     }

  341.   }

  342.   // Output describes

  343.   auto size_out = op_desc->GetOutputsSize();

  344.   AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "output_desc_nums", &size_out);

  345.   if (size_out > 0) {

  346.     for (uint32_t i = 0; i < size_out; i++) {

  347.       auto output_desc = op_desc->GetOutputDescPtr(i);

  348.       if (output_desc != nullptr) {

  349.         auto data_type = TypeUtils::DataTypeToSerialString(output_desc->GetDataType());

  350.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, "output_desc_dtype:" + std::to_string(i),

  351.                      &data_type);

  352.         auto origin_data_type = TypeUtils::DataTypeToSerialString(output_desc->GetOriginDataType());

  353.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  354.                      "output_desc_origin_dtype:" + std::to_string(i), &origin_data_type);

  355.         auto dims = output_desc->GetShape().GetDims();

  356.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "output_desc_shape:" + std::to_string(i),

  357.                      &dims);

  358.         auto dims_origin = output_desc->GetOriginShape().GetDims();

  359.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS,

  360.                      "output_desc_origin_shape:" + std::to_string(i), &dims_origin);

  361.         auto layout = TypeUtils::FormatToSerialString(output_desc->GetFormat());

  362.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, "output_desc_layout:" + std::to_string(i),

  363.                      &layout);

  364.         auto layout_origin = TypeUtils::FormatToSerialString(output_desc->GetOriginFormat());

  365.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  366.                      "output_desc_origin_layout:" + std::to_string(i), &layout_origin);

  367.         auto tensor_descriptor = output_desc->tensor_descriptor_.GetProtoMsg();

  368.         if (tensor_descriptor != nullptr) {

  369.           auto size = tensor_descriptor->size();

  370.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "output_desc_size:" + std::to_string(i),

  371.                        &size);

  372.           auto weight_size = tensor_descriptor->weight_size();

  373.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  374.                        "output_desc_weight_size:" + std::to_string(i), &weight_size);

  375.           auto device_type = tensor_descriptor->device_type();

  376.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  377.                        "output_desc_device_type:" + std::to_string(i), &device_type);

  378.           auto real_dim_cnt = tensor_descriptor->real_dim_cnt();

  379.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT,

  380.                        "output_desc_real_dim_cnt:" + std::to_string(i), &real_dim_cnt);

  381.           const auto &tensor_desc_map = tensor_descriptor->attr();

  382.           std::string suffix = ":" + std::to_string(i);

  383.           AddAttrProtoForAttrsFromAttrMap(tensor_desc_map, node_proto, kPrefixForOutputDesc, suffix);

  384.         } else {

  385.           GELOGW("Tensor descriptor is nullptr");

  386.           continue;

  387.         }

  388.       } else {

  389.         GELOGW("Output desc is nullptr");

  390.         continue;

  391.       }

  392.     }

  393.   }

  394. }

  395. 

  396. void OnnxUtils::AddAttrProtoForAttrsFromAttrMap(

  397.   const ::google::protobuf::Map<std::string, ::ge::proto::AttrDef> &attr_map, onnx::NodeProto *node_proto,

  398.   const std::string &prefix, const std::string &suffix) {

  399.   for (const auto &item : attr_map) {

  400.     auto attr_name = item.first;

  401.     auto attr_def = item.second;

  402.     auto attr_type = attr_def.value_case();

  403.     if (attr_type == ge::proto::AttrDef::kT) {

  404.       const auto &tensor_def = attr_def.t();

  405.       const auto &tensor_desc = tensor_def.desc();

  406.       auto data_type = ge::proto::DataType_Name(tensor_desc.dtype());

  407.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, prefix + attr_name + "_desc_dtype" + suffix,

  408.                    &data_type);

  409.       auto dims = tensor_desc.shape().dim();

  410.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, prefix + attr_name + "_desc_shape" + suffix,

  411.                    dims);

  412.       auto layout = tensor_desc.layout();

  413.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, prefix + attr_name + "_desc_layout" + suffix,

  414.                    &layout);

  415.       auto device_type = tensor_desc.device_type();

  416.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING,

  417.                    prefix + attr_name + "_desc_device_type" + suffix, &device_type);

  418.       if (kDumpLevel == DUMP_ALL) {

  419.         auto data = tensor_def.data();

  420.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, prefix + attr_name + "_data" + suffix,

  421.                      &data);

  422.       }

  423.     }

  424.     if (attr_type == ge::proto::AttrDef::kS) {

  425.       if (kDumpLevel == DUMP_ALL) {

  426.         auto str_value = attr_def.s();

  427.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRING, prefix + attr_name + suffix, &str_value);

  428.       }

  429.     }

  430.     if (attr_type == ge::proto::AttrDef::kI) {

  431.       auto int_value = attr_def.i();

  432.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, prefix + attr_name + suffix, &int_value);

  433.     }

  434.     if (attr_type == ge::proto::AttrDef::kF) {

  435.       auto float_value = attr_def.f();

  436.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_FLOAT, prefix + attr_name + suffix, &float_value);

  437.     }

  438.     if (attr_type == ge::proto::AttrDef::kB) {

  439.       auto int_value = static_cast<int64_t>(attr_def.b());

  440.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, prefix + attr_name + suffix, &int_value);

  441.     }

  442.     if (attr_type == ge::proto::AttrDef::kList) {

  443.       const auto &list_value = attr_def.list();

  444.       auto list_value_type = list_value.val_type();

  445.       if (list_value_type ==

  446.           ge::proto::AttrDef_ListValue_ListValueType::AttrDef_ListValue_ListValueType_VT_LIST_STRING) {

  447.         if (kDumpLevel == DUMP_ALL) {

  448.           const auto &strings = list_value.s();

  449.           AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRINGS, prefix + attr_name + suffix, strings);

  450.         }

  451.       }

  452.       if (list_value_type ==

  453.           ge::proto::AttrDef_ListValue_ListValueType::AttrDef_ListValue_ListValueType_VT_LIST_FLOAT) {

  454.         const auto &floats = list_value.f();

  455.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_FLOATS, prefix + attr_name + suffix, floats);

  456.       }

  457.       if (list_value_type == ge::proto::AttrDef_ListValue_ListValueType::AttrDef_ListValue_ListValueType_VT_LIST_INT) {

  458.         const auto &ints = list_value.i();

  459.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, prefix + attr_name + suffix, ints);

  460.       }

  461.       if (list_value_type == ge::proto::AttrDef_ListValue_ListValueType::AttrDef_ListValue_ListValueType_VT_LIST_BOOL) {

  462.         const auto &bools = list_value.b();

  463.         AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, prefix + attr_name + suffix, bools);

  464.       }

  465.     }

  466.   }

  467. }

  468. 

  469. void OnnxUtils::AddAttrProtoFromNodeMembers(const NodePtr &node, onnx::NodeProto *node_proto) {

  470.   if (node == nullptr) {

  471.     GELOGE(GRAPH_FAILED, "node is nullptr");

  472.     return;

  473.   }

  474.   // 1.Attributes added from node's methods

  475.   auto send_list = node->send_event_id_list_;

  476.   if (!send_list.empty()) {

  477.     AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "send_event_id_list", &send_list);

  478.   }

  479.   auto recv_list = node->recv_event_id_list_;

  480.   if (!recv_list.empty()) {

  481.     AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "recv_event_id_list", &recv_list);

  482.   }

  483.   auto op_desc = node->op_;

  484.   if (op_desc != nullptr) {

  485.     // for input_name_idx_ in opdesc

  486.     auto input_name_2_indexs = op_desc->GetAllInputName();

  487.     ::google::protobuf::RepeatedPtrField<::std::string> input_names;

  488.     ::google::protobuf::RepeatedField<::google::protobuf::int64> input_indexes;

  489.     for (const auto &input_name_2_index : input_name_2_indexs) {

  490.       std::string input_name = input_name_2_index.first;

  491.       input_names.Add(std::move(input_name));

  492.       input_indexes.Add(input_name_2_index.second);

  493.     }

  494.     AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRINGS, "_input_name_key", input_names);

  495.     AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "_input_name_value", input_indexes);

  496.     // 2.Attributes added from node's op_(message OpDef)

  497.     // Input and out describes

  498.     AddAttrProtoForOpInAndOutDesc(node_proto, op_desc);

  499.     // Others

  500.     auto op_def = op_desc->op_def_.GetProtoMsg();

  501.     if (op_def != nullptr) {

  502.       auto id = op_def->id();

  503.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "id", &id);

  504.       auto stream_id = op_def->stream_id();

  505.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INT, "stream_id", &stream_id);

  506.       const auto &input_name = op_def->input_name();

  507.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRINGS, "input_name", input_name);

  508.       const auto &src_name = op_def->src_name();

  509.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRINGS, "src_name", src_name);

  510.       const auto &src_index = op_def->src_index();

  511.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "src_index", src_index);

  512.       const auto &dst_name = op_def->dst_name();

  513.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_STRINGS, "dst_name", dst_name);

  514.       const auto &dst_index = op_def->dst_index();

  515.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "dst_index", dst_index);

  516.       const auto &input_i = op_def->input_i();

  517.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "input_i", input_i);

  518.       const auto &output_i = op_def->output_i();

  519.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "output_i", output_i);

  520.       const auto &workspace = op_def->workspace();

  521.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "workspace", workspace);

  522.       const auto &workspace_bytes = op_def->workspace_bytes();

  523.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "workspace_bytes", workspace_bytes);

  524.       const auto &is_input_const = op_def->is_input_const();

  525.       AddAttrProto(node_proto, onnx::AttributeProto_AttributeType_INTS, "is_input_const", is_input_const);

  526.       const auto &op_def_attr_map = op_def->attr();

  527.       AddAttrProtoForAttrsFromAttrMap(op_def_attr_map, node_proto);

  528.     } else {

  529.       GELOGE(FAILED, "Opdef is nullptr");

  530.       return;

  531.     }

  532.   } else {

  533.     GELOGE(FAILED, "Opdesc is nullptr");

  534.     return;

  535.   }

  536. }

  537. 

  538. bool OnnxUtils::EncodeNodeDesc(const NodePtr &node, onnx::NodeProto *node_proto) {

  539.   if ((node == nullptr) || (node_proto == nullptr)) {

  540.     GELOGE(GRAPH_FAILED, "EncodeOpDesc: Input Para Node Invalid");

  541.     return false;

  542.   }

  543. 

  544.   // 2.Encode map<string, GeAttrValue> attrs_ to AttributeProto

  545.   for (auto &node_attr : node->attrs_) {

  546.     AddAttrProtoFromAttribute(node_attr, node_proto);

  547.   }

  548.   // 3.Encode ge::Node members to AttributeProto

  549.   AddAttrProtoFromNodeMembers(node, node_proto);

  550.   return true;

  551. }

  552. 

  553. void OnnxUtils::EncodeNodeLinkForNetronVisual(const NodePtr &node, onnx::NodeProto *node_proto) {

  554.   if ((node == nullptr) || (node_proto == nullptr)) {

  555.     GELOGE(GRAPH_FAILED, "EncodeNodeLinkForNetronVisual: Input Para Node Invalid");

  556.     return;

  557.   }

  558.   const auto &node_name = node->GetName();

  559.   for (const auto &out_data_anchor : node->GetAllOutDataAnchors()) {

  560.     if ((out_data_anchor != nullptr) && (!out_data_anchor->GetPeerInDataAnchors().empty())) {

  561.       node_proto->add_output(node_name + ":" + std::to_string(out_data_anchor->GetIdx()));

  562.     }

  563.   }

  564.   auto out_control_anchor = node->GetOutControlAnchor();

  565.   if ((out_control_anchor != nullptr) && (!out_control_anchor->GetPeerInControlAnchors().empty())) {

  566.     node_proto->add_output(node_name + kControlAnchorIndex);

  567.   }

  568. }

  569. 

  570. bool OnnxUtils::EncodeNodeLink(const NodePtr &node, onnx::NodeProto *node_proto) {

  571.   if ((node == nullptr) || (node_proto == nullptr)) {

  572.     GELOGE(GRAPH_FAILED, "EncodeNodeLink: Input Para Node Invalid");

  573.     return false;

  574.   }

  575.   node_proto->clear_input();

  576.   // 1. Add input by in data edge

  577.   for (const auto &in_data_anchor : node->GetAllInDataAnchors()) {

  578.     auto peer_out_anchor = in_data_anchor->GetPeerOutAnchor();

  579.     if ((peer_out_anchor != nullptr) && (peer_out_anchor->GetOwnerNode() != nullptr)) {

  580.       node_proto->add_input(peer_out_anchor->GetOwnerNode()->GetName() + ":" +

  581.                             std::to_string(peer_out_anchor->GetIdx()));

  582.     } else {

  583.       // Add "" input

  584.       node_proto->add_input("");

  585.     }

  586.   }

  587. 

  588.   // 2. Add input by in control edge

  589.   auto in_control_anchor = node->GetInControlAnchor();

  590.   if (in_control_anchor != nullptr) {

  591.     auto peer_out_anchors = in_control_anchor->GetPeerOutControlAnchors();

  592.     for (const auto &peer_out_anchor : peer_out_anchors) {

  593.       if (peer_out_anchor->GetOwnerNode()) {

  594.         node_proto->add_input(peer_out_anchor->GetOwnerNode()->GetName() + kControlAnchorIndex);

  595.       }

  596.     }

  597.   } else {

  598.     GELOGE(FAILED, "Incontrol anchor is nullptr");

  599.     return false;

  600.   }

  601. 

  602.   // 3. Add output for Netron visual support

  603.   EncodeNodeLinkForNetronVisual(node, node_proto);

  604.   return true;

  605. }

  606. 

  607. bool OnnxUtils::EncodeNode(const NodePtr &node, onnx::NodeProto *node_proto) {

  608.   if ((node == nullptr) || (node_proto == nullptr)) {

  609.     GELOGE(GRAPH_FAILED, "EncodeNode: Input Para Node Invalid");

  610.     return false;

  611.   }

  612.   // 1. Encode name and type

  613.   node_proto->set_name(node->GetName());

  614.   /// Netron believes that some operators, such as the activation operator of softplus, only have one input,

  615.   /// while the link relation of control anchor may exist in ge, resulting in two inputs. Therefore, "ge:" prefix

  616.   /// is added to correctly display the link relation at the expense of some color features

  617.   node_proto->set_op_type("ge:" + node->GetType());

  618. 

  619.   if (kDumpLevel != DUMP_WITH_OUT_DESC) {

  620.     // 2.for attr

  621.     if (!EncodeNodeDesc(node, node_proto)) {

  622.       GELOGE(GRAPH_FAILED, "Encode NodeDesc: %s failed", node->GetName().c_str());

  623.       return false;

  624.     }

  625.   }

  626.   // 3.for link info

  627.   return EncodeNodeLink(node, node_proto);

  628. }

  629. 

  630. void OnnxUtils::EncodeTypeProtoTensorType(const NodePtr &node, onnx::TypeProto_Tensor *tensor_type) {

  631.   if ((node == nullptr) || (tensor_type == nullptr)) {

  632.     GELOGE(GRAPH_FAILED, "EncodeTypeProtoTensorType: Input Para Node or tensor_type Invalid");

  633.     return;

  634.   }

  635.   const auto &op_desc = node->GetOpDesc();

  636.   if (op_desc != nullptr) {

  637.     uint32_t size_out = static_cast<uint32_t>(op_desc->GetOutputsSize());

  638.     if (size_out > 0) {

  639.       for (uint32_t i = 0; i < size_out; i++) {

  640.         const ConstGeTensorDescPtr &ge_tensor = op_desc->GetOutputDescPtr(i);

  641.         if (ge_tensor != nullptr) {

  642.           auto ge_data_type = ge_tensor->GetDataType();

  643.           auto onnx_data_type = EncodeDataType(ge_data_type);

  644.           tensor_type->set_elem_type(onnx_data_type);

  645.           onnx::TensorShapeProto *shape = tensor_type->mutable_shape();

  646.           if (shape != nullptr) {

  647.             for (auto d : ge_tensor->GetShape().GetDims()) {

  648.               auto dim = shape->add_dim();

  649.               dim->set_dim_value(d);

  650.             }

  651.           } else {

  652.             GELOGW("Shape is nullptr");

  653.             continue;

  654.           }

  655.         } else {

  656.           GELOGW("Ge tensor is nullptr");

  657.           continue;

  658.         }

  659.       }

  660.     }

  661.   } else {

  662.     GELOGW("OpDesc  Is Empty, nodeName %s nodeType %s", node->GetName().c_str(), node->GetType().c_str());

  663.     return;

  664.   }

  665. }

  666. 

  667. void OnnxUtils::EncodeValueInfo(const NodePtr &node, onnx::ValueInfoProto *value_info_proto) {

  668.   if ((node == nullptr) || (value_info_proto == nullptr)) {

  669.     GELOGE(GRAPH_FAILED, "EncodeValueInfo: Input Para Node or value_info_proto Invalid");

  670.     return;

  671.   }

  672.   value_info_proto->set_name(node->GetName());

  673.   onnx::TypeProto *t = value_info_proto->mutable_type();

  674.   onnx::TypeProto_Tensor *tensor_type = t->mutable_tensor_type();

  675.   EncodeTypeProtoTensorType(node, tensor_type);

  676. }

  677. 

  678. bool OnnxUtils::EncodeGraph(const ConstComputeGraphPtr &graph, onnx::GraphProto *graph_proto) {

  679.   if ((graph == nullptr) || (graph_proto == nullptr)) {

  680.     GELOGE(GRAPH_FAILED, "EncodeGraph: Input para Invalid");

  681.     return false;

  682.   }

  683.   graph_proto->set_name(graph->GetName());

  684.   // 1. Add graph inputs

  685.   for (const auto &input : graph->GetInputNodes()) {

  686.     auto value_info_proto = graph_proto->add_input();

  687.     EncodeValueInfo(input, value_info_proto);

  688.   }

  689.   // 2. Add graph outputs

  690.   for (const auto &output : graph->GetOutputNodes()) {

  691.     auto value_info_proto = graph_proto->add_output();

  692.     EncodeValueInfo(output, value_info_proto);

  693.   }

  694.   // 3. Add nodes

  695.   for (const auto &node : graph->GetDirectNode()) {

  696.     if (!EncodeNode(node, graph_proto->add_node())) {

  697.       GELOGW("EncodeNode failed");

  698.       continue;

  699.     }

  700.   }

  701.   return true;

  702. }

  703. 

  704. bool OnnxUtils::ConvertGeModelToModelProto(const ge::Model &model, onnx::ModelProto &model_proto) {

  705.   model_proto.set_model_version(model.GetVersion());

  706.   model_proto.set_ir_version(onnx::IR_VERSION);

  707.   model_proto.set_producer_name(model.GetName());

  708.   auto &graph = model.graph_;

  709.   auto compute_graph = GraphUtils::GetComputeGraph(graph);

  710.   if (compute_graph == nullptr) {

  711.     GELOGE(GRAPH_FAILED, "GetComputeGraph: return nullptr");

  712.     return false;

  713.   }

  714.   auto graph_proto = model_proto.mutable_graph();

  715.   if (graph_proto == nullptr) {

  716.     GELOGE(GRAPH_FAILED, "mutable_graph: %s return nullptr", compute_graph->GetName().c_str());

  717.     return false;

  718.   }

  719.   if (!EncodeGraph(compute_graph, graph_proto)) {

  720.     GELOGE(GRAPH_FAILED, "EncodeGraph: %s fail", compute_graph->GetName().c_str());

  721.     return false;

  722.   }

  723. 

  724.   // For subgraphs: a subgraph is represented by a node

  725.   for (const auto &sub_compute_graph : compute_graph->GetAllSubgraphs()) {

  726.     if (sub_compute_graph != nullptr) {

  727.       auto node_proto = graph_proto->add_node();

  728.       if (node_proto == nullptr) {

  729.         GELOGW("Node proto is nullptr");

  730.         continue;

  731.       }

  732.       node_proto->set_name(sub_compute_graph->GetName());

  733.       node_proto->set_op_type(kNodeTypeForSubgraph);

  734.       auto attr = node_proto->add_attribute();

  735.       attr->set_name("graph");

  736.       attr->set_type(onnx::AttributeProto_AttributeType_GRAPH);

  737.       auto sub_graph_proto = attr->mutable_g();

  738.       if (sub_graph_proto == nullptr) {

  739.         GELOGW("Sub graph proto is nullptr");

  740.         continue;

  741.       }

  742.       if (!EncodeGraph(sub_compute_graph, sub_graph_proto)) {

  743.         GELOGW("Encode sub graph: %s fail", sub_compute_graph->GetName().c_str());

  744.         continue;

  745.       }

  746.     } else {

  747.       GELOGW("Graph: %s subgraph is nullptr, skip EncodeGraph", compute_graph->GetName().c_str());

  748.       continue;

  749.     }

  750.   }

  751.   return true;

  752. }

  753. 

  754. // Part 2: from ONNX Protobuf convert to IR

  755. static std::map<onnx::TensorProto_DataType, ge::DataType> onnxDataTypeToGeMap = {

  756.   {onnx::TensorProto_DataType_INT64, DT_INT64},   {onnx::TensorProto_DataType_UINT64, DT_UINT64},

  757.   {onnx::TensorProto_DataType_FLOAT, DT_FLOAT},   {onnx::TensorProto_DataType_INT32, DT_INT32},

  758.   {onnx::TensorProto_DataType_UINT32, DT_UINT32}, {onnx::TensorProto_DataType_INT8, DT_INT8},

  759.   {onnx::TensorProto_DataType_UINT8, DT_UINT8},   {onnx::TensorProto_DataType_INT16, DT_INT16},

  760.   {onnx::TensorProto_DataType_UINT16, DT_UINT16}, {onnx::TensorProto_DataType_FLOAT16, DT_FLOAT16},

  761.   {onnx::TensorProto_DataType_DOUBLE, DT_DOUBLE}, {onnx::TensorProto_DataType_BOOL, DT_BOOL},

  762. };

  763. 

  764. ge::DataType OnnxUtils::DecodeDataType(onnx::TensorProto_DataType data_type) {

  765.   auto it = onnxDataTypeToGeMap.find(data_type);

  766.   if (it != onnxDataTypeToGeMap.end()) {

  767.     return it->second;

  768.   } else {

  769.     GELOGW("DecodeDataType: datatype not support %u", data_type);

  770.     return ge::DT_UNDEFINED;

  771.   }

  772. }

  773. 

  774. bool OnnxUtils::ParseNameIndex(const std::string &node_name_index, std::string &node_name, int32_t &index) {

  775.   auto sep = node_name_index.rfind(':');

  776.   if (sep == std::string::npos) {

  777.     return false;

  778.   }

  779.   node_name = node_name_index.substr(0, sep);

  780.   auto index_str = node_name_index.substr(sep + 1);

  781.   index = static_cast<int32_t>(std::strtol(index_str.c_str(), nullptr, 10));

  782.   return true;

  783. }

  784. 

  785. bool OnnxUtils::DecodeNodeLinkImp(const NodeLinkInfo &item, NodePtr &node_ptr) {

  786.   if (node_ptr == nullptr) {

  787.     GELOGE(GRAPH_FAILED, "DecodeNodeLinkImp: node_ptr is nullptr");

  788.     return false;

  789.   }

  790.   // Data edge

  791.   if (item.src_out_index >= 0) {

  792.     auto src_anchor = node_ptr->GetOutDataAnchor(item.src_out_index);

  793.     auto dst_anchor = item.dst_node->GetInDataAnchor(item.dst_in_index);

  794.     if ((src_anchor == nullptr) || (dst_anchor == nullptr)) {

  795.       GELOGE(GRAPH_FAILED, "Get data anchor failed %s:%d, %s:%d ", item.src_node_name.c_str(), item.src_out_index,

  796.              item.dst_node_name.c_str(), item.dst_in_index);

  797.       return false;

  798.     }

  799.     if (src_anchor->LinkTo(dst_anchor) != GRAPH_SUCCESS) {

  800.       GELOGE(GRAPH_FAILED, "Data Anchor: src_anchor->LinkTo(dst_anchor) failed");

  801.       return false;

  802.     }

  803.     // Control edge

  804.   } else {

  805.     auto src_anchor = node_ptr->GetOutControlAnchor();

  806.     auto dst_anchor = item.dst_node->GetInControlAnchor();

  807.     if ((src_anchor == nullptr) || (dst_anchor == nullptr)) {

  808.       GELOGE(GRAPH_FAILED, "Get control anchor failed %s:%d, %s:%d ", item.src_node_name.c_str(), item.src_out_index,

  809.              item.dst_node_name.c_str(), item.dst_in_index);

  810.       return false;

  811.     }

  812.     if (src_anchor->LinkTo(dst_anchor) != GRAPH_SUCCESS) {

  813.       GELOGE(GRAPH_FAILED, "Control Anchor: src_anchor->LinkTo(dst_anchor) failed");

  814.       return false;

  815.     }

  816.   }

  817.   return true;

  818. }

  819. 

  820. bool OnnxUtils::DecodeNodeLink(const std::vector<onnx::NodeProto> &node_proto_vector,

  821.                                const std::map<std::string, NodePtr> &node_map) {

  822.   for (const auto &node_proto : node_proto_vector) {

  823.     const auto &node_name = node_proto.name();

  824.     auto dst_node = node_map.find(node_name);

  825.     if ((dst_node == node_map.end()) || (dst_node->second == nullptr)) {

  826.       GELOGE(GRAPH_FAILED, "destination node: %s find failed or is nullptr", node_name.c_str());

  827.       return false;

  828.     }

  829.     int32_t dst_index = 0;

  830.     for (const auto &input : node_proto.input()) {

  831.       std::string input_node_name;

  832.       int32_t index = 0;

  833.       if (ParseNameIndex(input, input_node_name, index)) {

  834.         auto item = NodeLinkInfo{input_node_name, index, dst_node->second, dst_index, node_proto.name()};

  835.         auto src_node = node_map.find(input_node_name);

  836.         if (src_node == node_map.end()) {

  837.           GELOGE(GRAPH_FAILED, "find src node: %s failed", input_node_name.c_str());

  838.           return false;

  839.         }

  840.         auto node_ptr = src_node->second;

  841.         if (node_ptr == nullptr) {

  842.           GELOGE(GRAPH_FAILED, "src node: %s is nullptr", input_node_name.c_str());

  843.           return false;

  844.         }

  845.         if (!DecodeNodeLinkImp(item, node_ptr)) {

  846.           GELOGE(GRAPH_FAILED, "DecodeNodeLinkImp node: %s failed", input_node_name.c_str());

  847.           return false;

  848.         }

  849.       }

  850.       if (index >= 0) {

  851.         dst_index++;

  852.       }

  853.     }

  854.   }

  855.   return true;

  856. }

  857. 

  858. void OnnxUtils::DecodeAttribute(const onnx::AttributeProto &attr_proto, std::vector<std::string> &strings) {

  859.   if (attr_proto.type() != onnx::AttributeProto_AttributeType_STRINGS) {

  860.     GELOGE(GRAPH_FAILED, "Attribute %s call wrong decode attribute function", attr_proto.name().c_str());

  861.     return;

  862.   }

  863.   for (int i = 0; i < attr_proto.strings_size(); i++) {

  864.     strings.push_back(attr_proto.strings(i));

  865.   }

  866. }

  867. 

  868. void OnnxUtils::DecodeAttribute(const onnx::AttributeProto &attr_proto, std::string &value) {

  869.   if (attr_proto.type() != onnx::AttributeProto_AttributeType_STRING) {

  870.     GELOGE(GRAPH_FAILED, "Attribute %s call wrong decode attribute function", attr_proto.name().c_str());

  871.     return;

  872.   }

  873.   value = attr_proto.s();

  874. }

  875. 

  876. void OnnxUtils::DecodeAttribute(const onnx::AttributeProto &attr_proto, std::vector<int64_t> &ints) {

  877.   if (attr_proto.type() != onnx::AttributeProto_AttributeType_INTS) {

  878.     GELOGE(GRAPH_FAILED, "Attribute %s call wrong decode attribute function", attr_proto.name().c_str());

  879.     return;

  880.   }

  881.   for (int i = 0; i < attr_proto.ints_size(); i++) {

  882.     ints.push_back(attr_proto.ints(i));

  883.   }

  884. }

  885. 

  886. void OnnxUtils::DecodeAttribute(const onnx::AttributeProto &attr_proto, int64_t &value) {

  887.   if (attr_proto.type() != onnx::AttributeProto_AttributeType_INT) {

  888.     GELOGE(GRAPH_FAILED, "Attribute %s call wrong decode attribute function", attr_proto.name().c_str());

  889.     return;

  890.   }

  891.   value = attr_proto.i();

  892. }

  893. 

  894. void OnnxUtils::DecodeNodeAttributeForOpInDesc(const onnx::AttributeProto &attr_proto,

  895.                                                const std::string &attr_name_for_input_desc, int32_t index,

  896.                                                OpDescPtr &op_desc) {

  897.   if (op_desc->MutableInputDesc(static_cast<uint32_t>(index)) == nullptr) {

  898.     GELOGE(GRAPH_FAILED, "[op name %s,attr name %s]op_desc->MutableInputDesc(static_cast<uint32_t>(index)) is nullptr",

  899.            op_desc->GetName().c_str(), attr_name_for_input_desc.c_str());

  900.     return;

  901.   }

  902.   if (attr_name_for_input_desc == "input_desc_dtype") {

  903.     auto data_type = TypeUtils::SerialStringToDataType(attr_proto.s());

  904.     op_desc->MutableInputDesc(static_cast<uint32_t>(index))->SetDataType(data_type);

  905.   } else if (attr_name_for_input_desc == "input_desc_shape") {

  906.     std::vector<std::int64_t> ints;

  907.     DecodeAttribute(attr_proto, ints);

  908.     GeShape ge_shape(ints);

  909.     op_desc->MutableInputDesc(static_cast<uint32_t>(index))->SetShape(ge_shape);

  910.   } else if (attr_name_for_input_desc == "input_desc_layout") {

  911.     auto data_format = TypeUtils::SerialStringToFormat(attr_proto.s());

  912.     op_desc->MutableInputDesc(static_cast<uint32_t>(index))->SetFormat(data_format);

  913.   } else if (attr_name_for_input_desc == "input_desc_origin_shape") {

  914.     std::vector<std::int64_t> ints;

  915.     DecodeAttribute(attr_proto, ints);

  916.     GeShape ge_shape(ints);

  917.     op_desc->MutableInputDesc(static_cast<uint32_t>(index))->SetOriginShape(ge_shape);

  918.   } else if (attr_name_for_input_desc == "input_desc_origin_layout") {

  919.     auto data_format = TypeUtils::SerialStringToFormat(attr_proto.s());

  920.     op_desc->MutableInputDesc(static_cast<uint32_t>(index))->SetOriginFormat(data_format);

  921.   } else if (attr_name_for_input_desc == "input_desc_size") {

  922.     int64_t input_size = 0;

  923.     auto tensor_descriptor = op_desc->MutableInputDesc(static_cast<uint32_t>(index))->tensor_descriptor_.GetProtoMsg();

  924.     DecodeAttribute(attr_proto, input_size);

  925.     tensor_descriptor->set_size(input_size);

  926.   } else if (attr_name_for_input_desc == "input_desc_data_offset") {

  927.     auto tensor_descriptor = op_desc->MutableInputDesc(static_cast<uint32_t>(index))->tensor_descriptor_.GetProtoMsg();

  928.     int64_t offset = 0;

  929.     DecodeAttribute(attr_proto, offset);

  930.     tensor_descriptor->set_data_offset(offset);

  931.   } else {

  932.     return;

  933.   }

  934. }

  935. 

  936. void OnnxUtils::DecodeNodeAttributeForOpOutDesc(const onnx::AttributeProto &attr_proto,

  937.                                                 const std::string &attr_name_for_output_desc, int32_t index,

  938.                                                 OpDescPtr &op_desc) {

  939.   if (op_desc->MutableOutputDesc(static_cast<uint32_t>(index)) == nullptr) {

  940.     GELOGE(GRAPH_FAILED, "[op name %s,attr name %s]op_desc->MutableOutputDesc(static_cast<uint32_t>(index)) is nullptr",

  941.            op_desc->GetName().c_str(), attr_name_for_output_desc.c_str());

  942.     return;

  943.   }

  944.   if (attr_name_for_output_desc == "output_desc_dtype") {

  945.     auto data_type = TypeUtils::SerialStringToDataType(attr_proto.s());

  946.     op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->SetDataType(data_type);

  947.   } else if (attr_name_for_output_desc == "output_desc_shape") {

  948.     std::vector<std::int64_t> ints;

  949.     DecodeAttribute(attr_proto, ints);

  950.     GeShape ge_shape(ints);

  951.     op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->SetShape(ge_shape);

  952.   } else if (attr_name_for_output_desc == "output_desc_layout") {

  953.     auto data_format = TypeUtils::SerialStringToFormat(attr_proto.s());

  954.     op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->SetFormat(data_format);

  955.   } else if (attr_name_for_output_desc == "output_desc_origin_shape") {

  956.     std::vector<std::int64_t> ints;

  957.     DecodeAttribute(attr_proto, ints);

  958.     GeShape ge_shape(ints);

  959.     op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->SetOriginShape(ge_shape);

  960.   } else if (attr_name_for_output_desc == "output_desc_origin_layout") {

  961.     auto data_format = TypeUtils::SerialStringToFormat(attr_proto.s());

  962.     op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->SetOriginFormat(data_format);

  963.   } else if (attr_name_for_output_desc == "output_desc_size") {

  964.     int64_t output_size = 0;

  965.     auto tensor_descriptor = op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->tensor_descriptor_.GetProtoMsg();

  966.     DecodeAttribute(attr_proto, output_size);

  967.     tensor_descriptor->set_size(output_size);

  968.   } else if (attr_name_for_output_desc == "output_desc_data_offset") {

  969.     auto tensor_descriptor = op_desc->MutableOutputDesc(static_cast<uint32_t>(index))->tensor_descriptor_.GetProtoMsg();

  970.     int64_t offset = 0;

  971.     DecodeAttribute(attr_proto, offset);

  972.     tensor_descriptor->set_data_offset(offset);

  973.   } else {

  974.     return;

  975.   }

  976. }

  977. 

  978. void OnnxUtils::DecodeNodeAttributeForOpInAndOutDesc(const onnx::AttributeProto &attr_proto,

  979.                                                      const std::string &attr_name_for_input_output_desc, int32_t index,

  980.                                                      OpDescPtr &op_desc) {

  981.   if (op_desc == nullptr) {

  982.     GELOGE(GRAPH_FAILED, "op_desc is nullptr");

  983.     return;

  984.   }

  985.   if (attr_name_for_input_output_desc.substr(0, kInputPrefixLength) == "input") {

  986.     DecodeNodeAttributeForOpInDesc(attr_proto, attr_name_for_input_output_desc, index, op_desc);

  987.   } else if (attr_name_for_input_output_desc.substr(0, kOutputPrefixLength) == "output") {

  988.     DecodeNodeAttributeForOpOutDesc(attr_proto, attr_name_for_input_output_desc, index, op_desc);

  989.   } else {

  990.     return;

  991.   }

  992. }

  993. 

  994. void OnnxUtils::DecodeNodeAttributeForOpDef(const onnx::AttributeProto &attr_proto, ge::proto::OpDef &op_def) {

  995.   auto attr_map = op_def.mutable_attr();

  996.   const auto &attr_name = attr_proto.name();

  997.   ge::proto::AttrDef op_attr;

  998.   int64_t value = 0;

  999.   DecodeAttribute(attr_proto, value);

  1000.   op_attr.set_i(value);

  1001.   attr_map->insert(AttrDefPair(attr_name, op_attr));

  1002. }

  1003. 

  1004. void OnnxUtils::DecodeNodeAttributeForOpDesc(const onnx::AttributeProto &attr_proto, OpDescPtr &op_desc) {

  1005.   if (op_desc == nullptr) {

  1006.     GELOGE(GRAPH_FAILED, "DecodeNodeAttributeForOpDesc: op_desc is nullptr");

  1007.     return;

  1008.   }

  1009.   const auto &attr_name = attr_proto.name();

  1010.   std::string attr_name_for_input_output_desc;

  1011.   int32_t index = 0;

  1012.   if (!ParseNameIndex(attr_name, attr_name_for_input_output_desc, index)) {

  1013.     if (attr_name == "id") {

  1014.       op_desc->SetId(attr_proto.i());

  1015.     } else if (attr_name == "stream_id") {

  1016.       op_desc->SetStreamId(attr_proto.i());

  1017.     } else if (attr_name == "src_name") {

  1018.       std::vector<std::string> strings;

  1019.       DecodeAttribute(attr_proto, strings);

  1020.       op_desc->SetSrcName(strings);

  1021.     } else if (attr_name == "dst_name") {

  1022.       std::vector<std::string> strings;

  1023.       DecodeAttribute(attr_proto, strings);

  1024.       op_desc->SetDstName(strings);

  1025.     } else if (attr_name == "src_index") {

  1026.       std::vector<std::int64_t> ints;

  1027.       DecodeAttribute(attr_proto, ints);

  1028.       op_desc->SetSrcIndex(ints);

  1029.     } else if (attr_name == "dst_index") {

  1030.       std::vector<std::int64_t> ints;

  1031.       DecodeAttribute(attr_proto, ints);

  1032.       op_desc->SetDstIndex(ints);

  1033.     } else if (attr_name == "fusion_scope") {

  1034.       DecodeNodeAttributeForOpDef(attr_proto, *op_desc->op_def_.GetProtoMsg());

  1035.     } else if (attr_name == "input_i") {

  1036.       std::vector<std::int64_t> ints;

  1037.       DecodeAttribute(attr_proto, ints);

  1038.       op_desc->SetInputOffset(ints);

  1039.     } else if (attr_name == "output_i") {

  1040.       std::vector<std::int64_t> ints;

  1041.       DecodeAttribute(attr_proto, ints);

  1042.       op_desc->SetOutputOffset(ints);

  1043.     } else {

  1044.       return;

  1045.     }

  1046.     // Update input and output desc

  1047.   } else {

  1048.     DecodeNodeAttributeForOpInAndOutDesc(attr_proto, attr_name_for_input_output_desc, index, op_desc);

  1049.   }

  1050. }

  1051. 

  1052. bool OnnxUtils::DecodeNodeDesc(const onnx::NodeProto *node_proto, OpDescPtr &op_desc) {

  1053.   if (op_desc == nullptr || node_proto == nullptr) {

  1054.     GELOGE(GRAPH_FAILED, " Op_desc is nullptr or node_proto is nullptr");

  1055.     return false;

  1056.   }

  1057.   // 1. Decode node_proto name and type

  1058.   op_desc->SetName(node_proto->name());

  1059.   const auto &node_type_with_ge_prefix = node_proto->op_type();

  1060.   auto sep = node_type_with_ge_prefix.find(':');

  1061.   if (sep == std::string::npos) {

  1062.     return false;

  1063.   }

  1064.   auto node_type = node_type_with_ge_prefix.substr(sep + 1);

  1065.   op_desc->SetType(node_type);

  1066.   // 2. Add empty input and output desc

  1067.   for (const auto &attr : node_proto->attribute()) {

  1068.     if (attr.name() == "input_desc_nums") {

  1069.       auto size_in = attr.i();

  1070.       for (int64_t i = 0; i < size_in; i++) {

  1071.         GeTensorDesc ge_tensor_desc;

  1072.         GE_CHK_BOOL_EXEC(op_desc->AddInputDesc(ge_tensor_desc) == GRAPH_SUCCESS, continue, "Add inputdesc failed.");

  1073.       }

  1074.     }

  1075.     if (attr.name() == "output_desc_nums") {

  1076.       auto size_out = attr.i();

  1077.       for (int64_t i = 0; i < size_out; i++) {

  1078.         GeTensorDesc ge_tensor_desc;

  1079.         GE_CHK_BOOL_EXEC(op_desc->AddOutputDesc(ge_tensor_desc) == GRAPH_SUCCESS, continue, "Add outputdesc failed.");

  1080.       }

  1081.     }

  1082.   }

  1083.   // 3.Decode node_proto attributes

  1084.   for (int i = 0; i < node_proto->attribute_size(); i++) {

  1085.     DecodeNodeAttributeForOpDesc(node_proto->attribute(i), op_desc);

  1086.   }

  1087.   return true;

  1088. }

  1089. 

  1090. bool OnnxUtils::DecodeGraph(int recursion_depth, const onnx::GraphProto &graph_proto, ComputeGraphPtr &graph) {

  1091.   if (recursion_depth > kMaxRecursionDepth) {

  1092.     GELOGE(GRAPH_FAILED, "DecodeGraph: recursion depth is too large, abort");

  1093.     return false;

  1094.   }

  1095. 

  1096.   graph = ComGraphMakeShared<ge::ComputeGraph>(graph_proto.name());

  1097.   GE_CHK_BOOL_EXEC(graph != nullptr, return false, "ComputeGraph make shared failed");

  1098.   /// 1. Decode all nodes first, node should include input

  1099.   /// and output nodes and nodes which represent sub graphs

  1100.   std::map<std::string, NodePtr> node_map;

  1101.   std::vector<onnx::NodeProto> node_proto_vector;

  1102.   for (const auto &node_proto : graph_proto.node()) {

  1103.     // a. nodes represent sub graphs

  1104.     if (node_proto.op_type() == kNodeTypeForSubgraph) {

  1105.       ComputeGraphPtr compute_graph;

  1106.       // in this case, node only have one attr, whose type is AttributeProto_AttributeType_GRAPH

  1107.       const auto &node_attr = node_proto.attribute(0);

  1108.       if ((node_attr.type() == onnx::AttributeProto_AttributeType_GRAPH) &&

  1109.           DecodeGraph(recursion_depth + 1, node_attr.g(), compute_graph)) {

  1110.         (void)graph->AddSubGraph(compute_graph);

  1111.       } else {

  1112.         GELOGE(GRAPH_FAILED, "Decode sub graph %s failed with node type:%d", node_proto.name().c_str(),

  1113.                node_attr.type());

  1114.         return false;

  1115.       }

  1116.       // b. direct nodes in graph

  1117.     } else {

  1118.       node_proto_vector.push_back(node_proto);

  1119.       OpDescPtr op_desc = ComGraphMakeShared<OpDesc>();

  1120.       // b.1 For node desc

  1121.       if (!DecodeNodeDesc(&node_proto, op_desc)) {

  1122.         GELOGE(GRAPH_FAILED, "Decode node desc %s failed ", node_proto.name().c_str());

  1123.         return false;

  1124.       }

  1125.       auto node = graph->AddNode(op_desc);

  1126.       node_map.insert(std::make_pair(node_proto.name(), node));

  1127.     }

  1128.   }

  1129.   /// We get all nodes in graph here

  1130.   /// b.2 For node link

  1131.   if (!DecodeNodeLink(node_proto_vector, node_map)) {

  1132.     GELOGE(GRAPH_FAILED, "Decode node link failed");

  1133.     return false;

  1134.   }

  1135. 

  1136.   // 2. Add inputs nodes for graph

  1137.   for (const auto &input : graph_proto.input()) {

  1138.     const auto &input_node_name = input.name();

  1139.     auto input_node_item = node_map.find(input_node_name);

  1140.     if (input_node_item == node_map.end()) {

  1141.       GELOGE(GRAPH_FAILED, "cannot find graph's input node %s in node_", input_node_name.c_str());

  1142.       return false;

  1143.     }

  1144.     auto ret = graph->AddInputNode(input_node_item->second);

  1145.     GE_CHK_BOOL_EXEC(ret != nullptr, continue, "Add inputnode failed");

  1146.   }

  1147.   // 3. Add outputs nodes for graph

  1148.   for (const auto &output : graph_proto.output()) {

  1149.     const auto &output_node_name = output.name();

  1150.     auto output_node_item = node_map.find(output_node_name);

  1151.     if (output_node_item == node_map.end()) {

  1152.       GELOGE(GRAPH_FAILED, "cannot find graph's output node %s in node_", output_node_name.c_str());

  1153.       return false;

  1154.     }

  1155.     auto ret = graph->AddOutputNode(output_node_item->second);

  1156.     if (ret == nullptr) {

  1157.       GELOGW("Add outputnode failed,out put node is %s", output_node_name.c_str());

  1158.       continue;

  1159.     }

  1160.   }

  1161.   return true;

  1162. }

  1163. 

  1164. bool OnnxUtils::ConvertModelProtoToGeModel(const onnx::ModelProto &model_proto, ge::Model &model) {

  1165.   model.name_ = model_proto.producer_name();

  1166.   model.version_ = static_cast<uint32_t>(model_proto.model_version());

  1167. 

  1168.   auto &graph_proto = model_proto.graph();

  1169.   ComputeGraphPtr compute_graph;

  1170.   // 0 means recursion depth, father call

  1171.   if (!DecodeGraph(0, graph_proto, compute_graph)) {

  1172.     GELOGE(GRAPH_FAILED, "Decode compute graph from graph_proto failed");

  1173.     return false;

  1174.   }

  1175.   model.graph_ = GraphUtils::CreateGraphFromComputeGraph(compute_graph);

  1176.   return true;

  1177. }

  1178. }  // namespace ge