wangwei
/
parser
Not watched
1
0
Fork 0
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

increase parser ut

pull/433/head
jwx930962 4 years ago
parent
63db8bbf1a
commit
a948bbfd35
3 changed files with 286 additions and 1 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +109
    -1
      tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc
  2. +73
    -0
      tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc
  3. +104
    -0
      tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc

+ 109
- 1
tests/ut/parser/testcase/caffe_parser_testcase/caffe_parser_unittest.cc View File

@@ -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<ge::OpDesc>("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<ge::OpDesc>("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<ge::OpDesc>("Abs", "AbsVal");

std::shared_ptr<OpParserFactory> factory = OpParserFactory::Instance(domi::CAFFE);
std::shared_ptr<OpParser> op_parser = factory->CreateOpParser("Abs");

Status ret = modelParser.ParseOpParam(*layer, op_desc_src, op_parser);
EXPECT_EQ(ret, PARAM_INVALID);
}

} // namespace ge

+ 73
- 0
tests/ut/parser/testcase/onnx_parser_testcase/onnx_parser_unittest.cc View File

@@ -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

+ 104
- 0
tests/ut/parser/testcase/tensorflow_parser_testcase/tensorflow_parser_unittest.cc View File

@@ -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<ge::OpDesc>("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<std::string, tensorflow::AttrValue> *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

Write Preview
Loading…
Cancel
Save