From a948bbfd35b69d9c86b34e91813dae1357528676 Mon Sep 17 00:00:00 2001 From: jwx930962 Date: Sat, 18 Dec 2021 17:40:27 +0800 Subject: [PATCH] increase parser ut --- .../caffe_parser_unittest.cc | 110 +++++++++++++++++- .../onnx_parser_unittest.cc | 73 ++++++++++++ .../tensorflow_parser_unittest.cc | 104 +++++++++++++++++ 3 files changed, 286 insertions(+), 1 deletion(-) diff --git a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc index 7481cdf..4b32e98 100644 --- a/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc +++ b/tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc @@ -38,6 +38,7 @@ #include "parser/caffe/caffe_op_parser.h" #include "graph/operator_reg.h" #include "parser/common/acl_graph_parser_util.h" +#include "parser/caffe/caffe_reshape_parser.h" #undef protected #undef private @@ -269,7 +270,6 @@ TEST_F(UtestCaffeParser, modelparser_parsefrommemory_success) std::string modelFile = caseDir + "/caffe_model/caffe_add.pbtxt"; const char* tmp_tf_pb_model = modelFile.c_str(); - printf("------------model_file:%s---------------------\n", tmp_tf_pb_model); ge::Graph graph; ge::ComputeGraphPtr compute_graph = ge::GraphUtils::GetComputeGraph(graph); @@ -648,6 +648,18 @@ TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_test) EXPECT_EQ(ret, FAILED); } +TEST_F(UtestCaffeParser, CaffeModelParser_ParseInput_test2) +{ + CaffeModelParser modelParser; + domi::caffe::NetParameter net; + net.add_input("111"); + bool input_data_flag = true; + + net.add_input_shape(); + Status ret = modelParser.ParseInput(net, input_data_flag); + EXPECT_EQ(ret, SUCCESS); +} + TEST_F(UtestCaffeParser, CaffeModelParser_CustomProtoParse_test) { CaffeModelParser modelParser; @@ -806,4 +818,100 @@ TEST_F(UtestCaffeParser, CaffeWeightsParser_CheckNodes_test) EXPECT_EQ(ret, SUCCESS); } +TEST_F(UtestCaffeParser, CaffeModelParser_RemapTopNameByLayer_test) +{ + CaffeModelParser model_parser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + + std::string top_name = "Abs"; + int index = 1; + + model_parser.RemapTopNameByLayer(*layer, top_name, index); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_SaveDataLayerTops_test) +{ + CaffeModelParser model_parser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + + Status ret = model_parser.SaveDataLayerTops(*layer); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_ReadCaffeModelFromText_test) +{ + CaffeModelParser modelParser; + std::string case_dir = __FILE__; + case_dir = case_dir.substr(0, case_dir.find_last_of("/")); + std::string model_file = case_dir + "/caffe_model/caffe.pbtxt"; + const char *model_path = model_file.c_str(); + + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("Abs"); + layer->set_type("AbsVal"); + Status ret = modelParser.ReadCaffeModelFromText(model_path, &net); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestCaffeParser, CaffeReshapeParser_ParseParams_test) +{ + CaffeReshapeParser reshapeParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + domi::caffe::ReshapeParameter* reshape_param = layer->mutable_reshape_param(); + layer->add_bottom("bottom"); + layer->add_top("top"); + + ge::OpDescPtr op_desc_src = std::make_shared("Abs", "AbsVal"); + Status ret = reshapeParser.ParseParams(layer, op_desc_src); + EXPECT_EQ(ret, FAILED); + + domi::caffe::BlobShape *blob_shape = reshape_param->mutable_shape(); + blob_shape->add_dim(2); + blob_shape->add_dim(3); + reshape_param->set_axis(0); + reshape_param->set_num_axes(-1); + ret = reshapeParser.ParseParams(layer, op_desc_src); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestCaffeParser, CaffeReshapeParser_ParseWeights_test) +{ + CaffeReshapeParser reshapeParser; + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + domi::caffe::ReshapeParameter* reshape_param = layer->mutable_reshape_param(); + layer->add_bottom("bottom"); + layer->add_top("top"); + + ge::OpDescPtr op_desc_src = std::make_shared("Abs", "AbsVal"); + Status ret = reshapeParser.ParseWeights(layer, op_desc_src); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestCaffeParser, CaffeModelParser_ParseOpParam_test) +{ + CaffeModelParser modelParser; + + domi::caffe::NetParameter net; + domi::caffe::LayerParameter *layer = net.add_layer(); + layer->set_name("AbsVal"); + layer->set_type("AbsVal"); + + ge::OpDescPtr op_desc_src = std::make_shared("Abs", "AbsVal"); + + std::shared_ptr factory = OpParserFactory::Instance(domi::CAFFE); + std::shared_ptr op_parser = factory->CreateOpParser("Abs"); + + Status ret = modelParser.ParseOpParam(*layer, op_desc_src, op_parser); + EXPECT_EQ(ret, PARAM_INVALID); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc index a204b62..8241b72 100644 --- a/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc +++ b/tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc @@ -242,4 +242,77 @@ TEST_F(UtestOnnxParser, OnnxModelParser_ConvertToGeDataType_test) EXPECT_EQ(ret, ge::DataType::DT_UNDEFINED); } +TEST_F(UtestOnnxParser, OnnxModelParser_ParseConvertData_test) +{ + OnnxConstantParser constant_parser; + ge::onnx::TensorProto tensor_proto; + tensor_proto.set_data_type(ge::DataType::DT_UNDEFINED); + + ge::Tensor tensor; + int count = 1; + + Status ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, FAILED); + + tensor_proto.set_data_type(OnnxDataType::INT32); + count = 0; + ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, SUCCESS); + + tensor_proto.set_data_type(OnnxDataType::BFLOAT16); + count = 1; + ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, FAILED); + + tensor_proto.set_data_type(OnnxDataType::STRING); + ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, FAILED); + + tensor_proto.set_raw_data("Test"); + ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, SUCCESS); + + tensor_proto.set_data_type(OnnxDataType::FLOAT); + ret = constant_parser.ParseConvertData(tensor_proto, tensor, count); + EXPECT_EQ(ret, SUCCESS); +} + +TEST_F(UtestOnnxParser, OnnxConstantParser_ParseConvertTensor_test) +{ + OnnxConstantParser constant_parser; + ge::onnx::NodeProto input_node; + ge::onnx::AttributeProto *attribute = input_node.add_attribute(); + attribute->set_name("attribute"); + attribute->set_type(onnx::AttributeProto::AttributeType(1)); + attribute->set_f(1.0); + ge::onnx::TensorProto *attribute_tensor = attribute->mutable_t(); + attribute_tensor->set_data_type(1); + attribute_tensor->add_dims(4); + + ge::Tensor tensor; + Status ret = constant_parser.ParseConvertTensor(*attribute_tensor, tensor); + EXPECT_EQ(ret, FAILED); + + attribute_tensor->add_dims(-1); + ret = constant_parser.ParseConvertTensor(*attribute_tensor, tensor); + EXPECT_EQ(ret, FAILED); +} + +TEST_F(UtestOnnxParser, OnnxConstantParser_ParseConvertDataType_test) +{ + OnnxConstantParser constant_parser; + ge::onnx::NodeProto input_node; + ge::onnx::AttributeProto *attribute = input_node.add_attribute(); + attribute->set_name("attribute"); + attribute->set_type(onnx::AttributeProto::AttributeType(1)); + attribute->set_f(1.0); + ge::onnx::TensorProto *attribute_tensor = attribute->mutable_t(); + attribute_tensor->set_data_type(OnnxDataType::BFLOAT16); + attribute_tensor->add_dims(4); + + ge::Tensor tensor; + Status ret = constant_parser.ParseConvertDataType(*attribute_tensor, tensor); + EXPECT_EQ(ret, FAILED); +} + } // namespace ge diff --git a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc index 8d32633..3ff888a 100644 --- a/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc +++ b/tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc @@ -1655,6 +1655,14 @@ TEST_F(UtestTensorflowParser, parse_AddScopeInnerNode) // can't find in scope_inner_node_map ret = modelParser.AddScopeInnerNode(&modelParser, compute_graph, &graph_mutex, node_def); EXPECT_EQ(ret, PARAM_INVALID); + + std::string msg = "FastrcnnPredictions"; + ge::Operator *op = new Operator(); + modelParser.scope_inner_node_map_.insert({msg, op}); + // can't find in scope_inner_node_map + ret = modelParser.AddScopeInnerNode(&modelParser, compute_graph, &graph_mutex, node_def); + EXPECT_EQ(ret, PARAM_INVALID); + delete op; delete node_def; } @@ -1905,6 +1913,61 @@ TEST_F(UtestTensorflowParser, tensorflow_enter_test) { std::string modelFile = caseDir + "/tensorflow_model/test_enter.pb"; auto status = aclgrphParseTensorFlow(modelFile.c_str(), graph); EXPECT_EQ(status, SUCCESS); + + TensorFlowEnterParser enterParser; + ge::OpDescPtr op_dest = make_shared("Enter", ge::parser::ENTER); + NodeDef* node_def = initNodeDef(); + node_def->set_name("Enter"); + Status ret = enterParser.ParseParams(node_def, op_dest); + EXPECT_EQ(ret, FAILED); + + static const string KEY_SHAPE_LIST = "key_shape_list"; + static const string KEY_TENSOR_LIST = "key_tensor_list"; + static const string KEY_DEFAULT = "key_default"; + + google::protobuf::Map *node_attr_map = node_def->mutable_attr(); + domi::tensorflow::AttrValue dtype_attr_value; + dtype_attr_value.set_type(domi::tensorflow::DT_FLOAT); + (*node_attr_map)[TENSORFLOW_ATTR_T] = dtype_attr_value; + + //设置strides属性 + domi::tensorflow::AttrValue axis_attr_value; + ::tensorflow::AttrValue_ListValue* list = axis_attr_value.mutable_list(); + list->add_i(1); + list->add_i(2); + (*node_attr_map)[ge::SQUEEZE_ATTR_AXIS] = axis_attr_value; + + domi::tensorflow::AttrValue value; + domi::tensorflow::AttrValue df_attr_value; + df_attr_value.set_i((int64_t)ccTensorFormat_t::CC_TENSOR_NHWC); + + domi::tensorflow::AttrValue pad_attr_value; + pad_attr_value.set_i((int64_t)tensorflow::DT_FLOAT); + + domi::tensorflow::AttrValue shape; + shape.mutable_list()->add_i((int64)32); + shape.mutable_list()->add_i((int64)32); + shape.mutable_list()->add_i((int64)14); + + static const string KEY_TYPE_LIST = "key_type_list"; + const std::string ENTER_ATTR_FRAME_NAME = "frame_name"; + const std::string ATTR_NAME_OUTPUT_TENSOR_DESC = "output_tensor_desc"; + static const domi::tensorflow::DataType VALUE_TYPE = domi::tensorflow::DataType::DT_FLOAT; + value.clear_value(); + value.mutable_list()->add_type(VALUE_TYPE); + TensorFlowUtil::AddNodeAttr(KEY_TYPE_LIST, value, node_def); + + value.clear_value(); + domi::tensorflow::NameAttrList name_attr_list; + name_attr_list.mutable_attr()->insert({"serialize_datatype", pad_attr_value}); + name_attr_list.mutable_attr()->insert({"serialize_format", df_attr_value}); + name_attr_list.mutable_attr()->insert({"serialize_shape", shape}); + *(value.mutable_list()->add_func()) = name_attr_list; + + node_def->mutable_attr()->insert({ge::ENTER_ATTR_FRAME_NAME, value}); + node_def->mutable_attr()->insert({ge::ATTR_NAME_OUTPUT_TENSOR_DESC, value}); + ret = enterParser.ParseParams(node_def, op_dest); + EXPECT_EQ(ret, FAILED); } TEST_F(UtestTensorflowParser, tensorflow_VariableV2_test) { @@ -4231,4 +4294,45 @@ TEST_F(UtestTensorflowParser, parser_UppdateInputMap_test) delete graph; } +TEST_F(UtestTensorflowParser, tensorflow_ConstOpNeedUpdate) +{ + NodeDef *transpose_node = initNodeDef(); + TensorFlowModelParser modelParser; + modelParser.nodedef_map_["arg1"] = transpose_node; + bool ret = modelParser.ConstOpNeedUpdate("arg1"); + ASSERT_EQ(ret, true); + + ge::OpNodeContext op_node_context; + op_node_context.input_map["pre_node_a"].push_back({0, 0}); + op_node_context.input_map["pre_node_ctrl_in"].push_back({-1, -1}); // ctrl edges + op_node_context.output_map["post_node_b"].push_back({0, 0}); + op_node_context.output_map["post_node_c"].push_back({1, 0}); + op_node_context.output_map["post_node_d"].push_back({-1, -1}); + op_node_context.output_map["_Retval"].push_back({0, 1}); + modelParser.op_node_context_map_["arg1"] = op_node_context; + ret = modelParser.ConstOpNeedUpdate("arg1"); + ASSERT_EQ(ret, true); + + transpose_node->set_op("NULL"); + modelParser.nodedef_map_["arg2"] = transpose_node; + ret = modelParser.ConstOpNeedUpdate("arg2"); + ASSERT_EQ(ret, true); + delete transpose_node; +} + +TEST_F(UtestTensorflowParser, tensorflow_IsFusionOpChild) +{ + TensorFlowModelParser modelParser; + ge::ScopeFusionOpInfo info; + info.node_name = "node_name"; + info.fusion_node_name = "fusion_node_name"; + info.fusion_op_type = "fusion_op_type"; + info.description = "description"; + info.scope_pass = "scope_pass"; + + modelParser.fusion_op_children_["argv1"] = info; + bool ret = modelParser.IsFusionOpChild("argv1", &info); + ASSERT_EQ(ret, true); +} + } // namespace ge