st parser

tests/depends/ops_stub/ops_stub.h

@@ -299,6 +299,23 @@ REG_OP(Pooling)
     .ATTR(data_format, String, "NCHW")
     .OP_END_FACTORY_REG(Pooling)
 
+REG_OP(Flatten)
+    .INPUT(x, TensorType::ALL())
+    .OUTPUT(y, TensorType::ALL())
+    .OP_END_FACTORY_REG(Flatten)
+
+REG_OP(Softmax)
+    .INPUT(x, TensorType({DT_FLOAT, DT_FLOAT16}))
+        .OUTPUT(y, TensorType({DT_FLOAT, DT_FLOAT16}))
+        .ATTR(axis, Int, 0) // which mean compute which dims
+        .ATTR(algo, Int, 1) // 1 means using "subtract max from every point to avoid overflow",
+        // 0 means using "ubtract max from every point to avoid overflow"
+        // 2 means using "perform the Log softmax operation to avoid overflow"
+        // now is only support 1
+        .ATTR(alpha, Float, 1)
+        .ATTR(beta, Float, 0)
+        .OP_END_FACTORY_REG(Softmax)
+
 // for plugin
 static Status ParseParamsStub(const google::protobuf::Message* op_src, ge::Operator& op_dest) {
   return SUCCESS;

tests/st/testcase/test_caffe_parser.cc

@@ -32,10 +32,15 @@
 #include "parser/caffe/caffe_parser.h"
 #include "parser/caffe/caffe_data_parser.h"
 #include "parser/caffe/caffe_op_parser.h"
+#include "parser/caffe/caffe_custom_parser_adapter.h"
+#include "parser/caffe/caffe_op_parser.h"
+#include "graph/operator_reg.h"
+#include "parser/common/acl_graph_parser_util.h"
 #undef protected
 #undef private
 
 using namespace domi::caffe;
+using namespace ge;
 
 namespace ge {
 class STestCaffeParser : public testing::Test {
@@ -59,7 +64,6 @@ static ge::NodePtr GenNodeFromOpDesc(ge::OpDescPtr opDesc){
   if (!opDesc) {
     return nullptr;
   }
-
   static auto g = std::make_shared<ge::ComputeGraph>("g");
   return g->AddNode(std::move(opDesc));
 }
@@ -202,4 +206,161 @@ TEST_F(STestCaffeParser, convertWeights_success)
   delete layer;
 }
 
+TEST_F(STestCaffeParser, CaffeCustomParserAdapter_ParseWeights_success)
+{
+  CaffeCustomParserAdapter parserAdapter;
+  ge::OpDescPtr opDef = std::make_shared<ge::OpDesc>("","");
+  auto node_tmp = GenNodeFromOpDesc(opDef);
+  LayerParameter* layer = new LayerParameter();
+  Status ret = parserAdapter.ParseWeights(layer, node_tmp);
+  EXPECT_EQ(ret, SUCCESS);
+
+  BlobProto* blob = layer->add_blobs();
+  blob->add_data(1);
+  blob->add_data(1);
+  BlobShape* shap = blob->mutable_shape();
+  shap->add_dim(1);
+  shap->add_dim(2);
+
+  ret = parserAdapter.ParseWeights(layer, node_tmp);
+  EXPECT_EQ(ret, SUCCESS);
+
+  delete layer;
+}
+
+TEST_F(STestCaffeParser, CaffeCustomParserAdapter_ParseParams_success)
+{
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Data", "Input");
+  ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src);
+  ge::OpDescPtr op_dest = std::make_shared<ge::OpDesc>("Data", "Input");
+
+  CaffeCustomParserAdapter parserAdapter;
+  Status ret = parserAdapter.ParseParams(op_src, op_dest);
+  EXPECT_EQ(ret, PARAM_INVALID);
+}
+
+TEST_F(STestCaffeParser, CaffeDataParser_ParseParams_success)
+{
+  domi::caffe::NetParameter net;
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Data", "Input");
+  domi::caffe::LayerParameter* lay0 = net.add_layer();
+  lay0->set_name("conv");
+  lay0->set_type(ge::parser::DUMMY_DATA);
+
+  ge::OpDescPtr opDef = std::make_shared<ge::OpDesc>("","");
+  CaffeDataParser parserAdapter;
+  Status ret = parserAdapter.ParseParams(lay0, opDef);
+  EXPECT_EQ(ret, FAILED);
+
+  lay0->set_type(ge::parser::ATTR_NAME_INPUT_TENSOR_DESC);
+  ret = parserAdapter.ParseParams(lay0, opDef);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestCaffeParser, CaffeWeightsParser_Parse_test)
+{
+  CaffeWeightsParser weightParser;
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string model_file = case_dir + "/origin_models/ResNet-50-model.caffemodel";
+  const char *file = nullptr;
+  ge::ComputeGraphPtr graph;
+  Status ret = weightParser.Parse(file, graph);
+  EXPECT_EQ(ret, PARAM_INVALID);
+
+  file = model_file.c_str();
+  ret = weightParser.Parse(file, graph);
+  EXPECT_EQ(ret, PARAM_INVALID);
+
+  graph = std::make_shared<ComputeGraph>("test");
+  ret = weightParser.Parse(file, graph);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestCaffeParser, CaffeWeightsParser_ParseWeightByFusionProto_test)
+{
+  CaffeWeightsParser weightParser;
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string weight_file = case_dir + "/origin_models/ResNet-50-model.caffemodel";
+  std::string model_file = case_dir + "/origin_models/caffe.proto";
+  const char *weight_path = model_file.c_str();
+  std::string fusion_proto_path = model_file;
+  std::string fusion_proto_name = "caffe";
+  ge::ComputeGraphPtr graph = std::make_shared<ComputeGraph>("test");
+  Status ret = weightParser.ParseWeightByFusionProto(weight_path, fusion_proto_path, fusion_proto_name, graph);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestCaffeParser, CaffeWeightsParser_ParseFromMemory_test)
+{
+  CaffeWeightsParser weightParser;
+  std::string case_dir = __FILE__;
+  case_dir = case_dir.substr(0, case_dir.find_last_of("/"));
+  std::string weight_file = case_dir + "/origin_models/ResNet-50-model.caffemodel";
+  ge::ComputeGraphPtr graph;
+  const char *data = nullptr;
+  Status ret = weightParser.ParseFromMemory(data, 1, graph);
+  EXPECT_EQ(ret, PARAM_INVALID);
+
+  data = weight_file.c_str();
+  ret = weightParser.ParseFromMemory(data, 1, graph);
+  EXPECT_EQ(ret, PARAM_INVALID);
+
+  graph = std::make_shared<ComputeGraph>("test");
+  ret = weightParser.ParseFromMemory(data, 1, graph);
+  EXPECT_EQ(ret, domi::PARSE_WEIGHTS_FAILED);
+
+  CaffeModelParser model_parser;
+  ret = model_parser.ParseFromMemory(data, 1, graph);
+  EXPECT_EQ(ret, FAILED);
+}
+
+TEST_F(STestCaffeParser, CaffeWeightsParser_CreateCustomOperator_test)
+{
+  CaffeModelParser model_parser;
+
+  vector<ge::Operator> operators;
+  ge::OpDescPtr op_desc_src = std::make_shared<ge::OpDesc>("Data", "Input");
+  ge::Operator op_src = ge::OpDescUtils::CreateOperatorFromOpDesc(op_desc_src);
+  operators.emplace_back(op_src);
+  std::string op_name = "";
+  std::string op_type = "";
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *lay0 = net.add_layer();
+  lay0->set_name("Data");
+  lay0->set_type("Input");
+  Status ret = model_parser.CreateCustomOperator(op_name, op_type, &net, 1, operators);
+  EXPECT_EQ(ret, FAILED);
+
+  op_name = "Data";
+  op_type = "Input";
+
+  ret = model_parser.CreateCustomOperator(op_name, op_type, &net, 1, operators);
+  EXPECT_EQ(ret, SUCCESS);
+
+  model_parser.AddOutputInfoToContext(op_name, 1);
+}
+
+TEST_F(STestCaffeParser, CaffeWeightsParser_ParseOutputNodeTopInfo_test)
+{
+  CaffeModelParser model_parser;
+  AclGrphParseUtil acl_graph_parse_util;
+
+  domi::caffe::NetParameter net;
+  domi::caffe::LayerParameter *lay0 = net.add_layer();
+  lay0->set_name("Data");
+  lay0->set_type("Input");
+  Status ret = model_parser.ParseOutputNodeTopInfo(net);
+  EXPECT_EQ(ret, SUCCESS);
+
+  GetParserContext().type = domi::CAFFE;
+  string graph_name;
+  std::map<AscendString, AscendString> out_nodes_with_tensor_name1 = {
+    {AscendString(ge::ir_option::OUT_NODES), AscendString("Out_tensor_1;Out_tensor_2")}};
+  acl_graph_parse_util.ParseParamsBeforeGraph(out_nodes_with_tensor_name1, graph_name);
+  ret = model_parser.ParseOutputNodeTopInfo(net);
+  EXPECT_EQ(ret, PARAM_INVALID);
+}
+
 } // namespace ge