From d5676a14bd2157ac9514cb2d64e8c5138f0adb7a Mon Sep 17 00:00:00 2001 From: yeyunpeng Date: Tue, 2 Feb 2021 14:43:47 +0800 Subject: [PATCH] fix converter issue --- mindspore/lite/nnacl/infer/scatter_nd_infer.c | 3 ++ mindspore/lite/schema/ops.fbs | 4 +-- mindspore/lite/src/ops/ops_def.cc | 4 +-- mindspore/lite/src/ops/ops_utils.cc | 5 +++ mindspore/lite/tools/common/node_util.cc | 5 ++- .../converter/parser/onnx/onnx_pad_parser.cc | 7 ----- .../parser/tflite/tflite_pad_parser.cc | 7 ----- .../lite/tools/optimizer/common/gllo_utils.cc | 31 +++++++++++++++++++ .../lite/tools/optimizer/common/gllo_utils.h | 2 ++ .../optimizer/graph/inputs_adjust_pass.cc | 8 ++--- .../optimizer/graph/primitive_adjust_pass.cc | 31 +++++++++++++++++++ 11 files changed, 84 insertions(+), 23 deletions(-) diff --git a/mindspore/lite/nnacl/infer/scatter_nd_infer.c b/mindspore/lite/nnacl/infer/scatter_nd_infer.c index e6ea0557e8..bf2c893d8f 100644 --- a/mindspore/lite/nnacl/infer/scatter_nd_infer.c +++ b/mindspore/lite/nnacl/infer/scatter_nd_infer.c @@ -24,6 +24,9 @@ int ScatterNdInferShape(const TensorC *const *inputs, size_t inputs_size, Tensor } const TensorC *shape = inputs[0]; + if (shape->data_ == NULL) { + return NNACL_INFER_INVALID; + } // const TensorC *indices = inputs[1]; const TensorC *update = inputs[2]; TensorC *output = outputs[0]; diff --git a/mindspore/lite/schema/ops.fbs b/mindspore/lite/schema/ops.fbs index 9d2256c0fb..a3cdefb21a 100644 --- a/mindspore/lite/schema/ops.fbs +++ b/mindspore/lite/schema/ops.fbs @@ -727,8 +727,8 @@ table PowerGrad { } table PowFusion { - scale: float; - shift: float; + scale: float = 1; + shift: float = 0; } table PriorBox { diff --git a/mindspore/lite/src/ops/ops_def.cc b/mindspore/lite/src/ops/ops_def.cc index 83bc298dda..32150ea068 100644 --- a/mindspore/lite/src/ops/ops_def.cc +++ b/mindspore/lite/src/ops/ops_def.cc @@ -726,8 +726,8 @@ OP_ATTR(shift, float) OP_SCHEMA_DEF_END(PowerGrad) OP_SCHEMA_DEF(PowFusion) -OP_ATTR(scale, float) -OP_ATTR(shift, float) +OP_ATTR_WITH_VALUE(scale, float, 1) +OP_ATTR_WITH_VALUE(shift, float, 0) OP_SCHEMA_DEF_END(PowFusion) OP_SCHEMA_DEF(PriorBox) diff --git a/mindspore/lite/src/ops/ops_utils.cc b/mindspore/lite/src/ops/ops_utils.cc index dc15ede768..5bbf9eda7a 100644 --- a/mindspore/lite/src/ops/ops_utils.cc +++ b/mindspore/lite/src/ops/ops_utils.cc @@ -502,6 +502,10 @@ schema::PrimitiveT *ScaleFusionPrimitiveCreator(const AnfNodePtr &node) { auto ms_primc = GetValueNode>(node); return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr; } +schema::PrimitiveT *ScatterNdPrimitiveCreator(const AnfNodePtr &node) { + auto ms_primc = GetValueNode>(node); + return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr; +} schema::PrimitiveT *ShapePrimitiveCreator(const AnfNodePtr &node) { auto ms_primc = GetValueNode>(node); return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr; @@ -787,6 +791,7 @@ RegistryMSOps g_rsqrtPrimitiveCreatorRegistry("Rsqrt", RsqrtPrimitiveCreator); RegistryMSOps g_quantDTypeCastPrimitiveCreatorRegistry("QuantDTypeCast", QuantDTypeCastPrimitiveCreator); RegistryMSOps g_scalePrimitiveCreatorRegistry("Scale", ScaleFusionPrimitiveCreator); RegistryMSOps g_scaleFusionPrimitiveCreatorRegistry("ScaleFusion", ScaleFusionPrimitiveCreator); +RegistryMSOps g_scatterNdPrimitiveCreatorRegistry("ScatterNd", ScatterNdPrimitiveCreator); RegistryMSOps g_shapePrimitiveCreatorRegistry("Shape", ShapePrimitiveCreator); RegistryMSOps g_sigmoidCrossEntropyWithLogitsPrimitiveCreatorRegistry("SigmoidCrossEntropyWithLogits", SigmoidCrossEntropyWithLogitsPrimitiveCreator); diff --git a/mindspore/lite/tools/common/node_util.cc b/mindspore/lite/tools/common/node_util.cc index 9c5cd83b15..b24eec105c 100644 --- a/mindspore/lite/tools/common/node_util.cc +++ b/mindspore/lite/tools/common/node_util.cc @@ -49,7 +49,10 @@ static const std::vector nhwcOpList = { schema::PrimitiveType_InstanceNorm, schema::PrimitiveType_SpaceToDepth, schema::PrimitiveType_DepthToSpace, - schema::PrimitiveType_TopKFusion}; + schema::PrimitiveType_TopKFusion, + schema::PrimitiveType_BatchToSpace, + schema::PrimitiveType_SpaceToBatch, + schema::PrimitiveType_SpaceToBatchND}; static const std::vector nhwcOpAllInputList = { #ifdef SUPPORT_TRAIN diff --git a/mindspore/lite/tools/converter/parser/onnx/onnx_pad_parser.cc b/mindspore/lite/tools/converter/parser/onnx/onnx_pad_parser.cc index 59ce239a55..637aeab950 100644 --- a/mindspore/lite/tools/converter/parser/onnx/onnx_pad_parser.cc +++ b/mindspore/lite/tools/converter/parser/onnx/onnx_pad_parser.cc @@ -37,13 +37,6 @@ ops::PrimitiveC *OnnxPadParser::Parse(const onnx::GraphProto &onnx_graph, const paddings[i][1] = static_cast(onnx_node_attr.ints(i + size / 2)); } prim->set_paddings(paddings); - - std::vector> pads(size / 2, std::vector(2, 0)); - for (int i = 0; i < size / 2; i++) { - pads[i][0] = static_cast(onnx_node_attr.ints(i)); - pads[i][1] = static_cast(onnx_node_attr.ints(i + size / 2)); - } - prim->AddAttr("pads", MakeValue(pads)); } else if (attribute_name == "mode") { const auto &mode = onnx_node_attr.s(); if (mode == "constant") { diff --git a/mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.cc b/mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.cc index 4b55debac4..4823fd5022 100644 --- a/mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.cc +++ b/mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.cc @@ -49,13 +49,6 @@ ops::PrimitiveC *TflitePadParser::Parse(const std::unique_ptr return nullptr; } prim->set_paddings(paddings); - - std::vector> pads; - if (TransTfliteDataToVec2D(tflite_op->inputs.at(1), tflite_subgraph->tensors, tflite_model->buffers, pads)) { - MS_LOG(ERROR) << "get Pad -> paddings failed"; - return nullptr; - } - prim->AddAttr("pads", MakeValue(pads)); } else if (tflite_op_type == tflite::BuiltinOperator_MIRROR_PAD) { const auto &tflite_attr = tflite_op->builtin_options.AsMirrorPadOptions(); if (tflite_attr == nullptr) { diff --git a/mindspore/lite/tools/optimizer/common/gllo_utils.cc b/mindspore/lite/tools/optimizer/common/gllo_utils.cc index e2ee9a64bd..439579ca25 100644 --- a/mindspore/lite/tools/optimizer/common/gllo_utils.cc +++ b/mindspore/lite/tools/optimizer/common/gllo_utils.cc @@ -159,6 +159,37 @@ std::vector CastToInt(const ValuePtr &value) { return cur_value; } +std::vector> CastToVec2DInt(const ValuePtr &value) { + if (value == nullptr) { + MS_LOG(WARNING) << "valueptr is nullptr."; + return {}; + } + + std::vector> result_value; + if (utils::isa(value)) { + if (value->cast() + ->value() + .front() + ->cast() + ->value() + .front() + ->type() + ->number_type() == kNumberTypeInt64) { + auto origin_value = GetValue>>(value); + for (size_t i = 0; i < origin_value.size(); ++i) { + std::vector cur_value; + for (size_t j = 0; j < origin_value.at(i).size(); ++j) { + cur_value.push_back(static_cast(origin_value[i][j])); + } + result_value.push_back(cur_value); + } + } else { + result_value = GetValue>>(value); + } + } + return result_value; +} + bool CheckPrimitiveType(const AnfNodePtr &node, const PrimitivePtr &primitive_type) { if (node == nullptr) { lite::ReturnCode::GetSingleReturnCode()->UpdateReturnCode(lite::RET_NULL_PTR); diff --git a/mindspore/lite/tools/optimizer/common/gllo_utils.h b/mindspore/lite/tools/optimizer/common/gllo_utils.h index 163b1d6a67..02fe5f732c 100644 --- a/mindspore/lite/tools/optimizer/common/gllo_utils.h +++ b/mindspore/lite/tools/optimizer/common/gllo_utils.h @@ -37,6 +37,8 @@ namespace mindspore { namespace opt { std::vector CastToInt(const ValuePtr &value); +std::vector> CastToVec2DInt(const ValuePtr &value); + bool CheckPrimitiveType(const AnfNodePtr &node, const PrimitivePtr &primitive_type); bool IsRealCNodeKernel(const AnfNodePtr &node); diff --git a/mindspore/lite/tools/optimizer/graph/inputs_adjust_pass.cc b/mindspore/lite/tools/optimizer/graph/inputs_adjust_pass.cc index 958d825e9a..499f9b2b0f 100644 --- a/mindspore/lite/tools/optimizer/graph/inputs_adjust_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/inputs_adjust_pass.cc @@ -44,21 +44,21 @@ STATUS InputAdjustPass::AddAttrToInput(const FuncGraphPtr &func_graph, const CNo if (value_ptr != nullptr) { switch (flag) { case 1: { - auto value_data = GetValue(value_ptr); + auto value_data = CastToInt(value_ptr).front(); auto param_node = BuildIntValueParameterNode(func_graph, value_data, cnode->fullname_with_scope() + "_" + attr_name); inputs.push_back(param_node); break; } case 2: { - auto value_data = GetValue>(value_ptr); + auto value_data = CastToInt(value_ptr); auto param_node = BuildIntVecParameterNode(func_graph, value_data, cnode->fullname_with_scope() + "_" + attr_name); inputs.push_back(param_node); break; } case 3: { - auto value_data = GetValue>>(value_ptr); + auto value_data = CastToVec2DInt(value_ptr); auto param_node = BuildIntVec2DParameterNode(func_graph, value_data, cnode->fullname_with_scope() + "_" + attr_name); inputs.push_back(param_node); @@ -123,7 +123,7 @@ bool InputAdjustPass::Run(const FuncGraphPtr &func_graph) { status = AddAttrToInput(func_graph, cnode, 2, "axes", 2); } else if (CheckPrimitiveType(node, prim::kPrimPadFusion)) { MS_LOG(INFO) << "Adjust PadFusion"; - status = AddAttrToInput(func_graph, cnode, 2, "pads", 3); + status = AddAttrToInput(func_graph, cnode, 2, "paddings", 3); } else if (CheckPrimitiveType(node, prim::kPrimPowFusion)) { MS_LOG(INFO) << "Adjust PowFuison"; status = AddAttrToInput(func_graph, cnode, 2, "power", 4); diff --git a/mindspore/lite/tools/optimizer/graph/primitive_adjust_pass.cc b/mindspore/lite/tools/optimizer/graph/primitive_adjust_pass.cc index 23dbed4c76..c2e04342b5 100644 --- a/mindspore/lite/tools/optimizer/graph/primitive_adjust_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/primitive_adjust_pass.cc @@ -41,9 +41,11 @@ #include "ops/fusion/max_pool_fusion.h" #include "ops/fusion/mul_fusion.h" #include "ops/fusion/pad_fusion.h" +#include "ops/fusion/pow_fusion.h" #include "ops/fusion/prelu_fusion.h" #include "ops/fusion/reduce_fusion.h" #include "ops/fusion/scale_fusion.h" +#include "ops/fusion/slice_fusion.h" #include "ops/fusion/sub_fusion.h" #include "ops/fusion/tile_fusion.h" #include "ops/fusion/topk_fusion.h" @@ -65,6 +67,7 @@ #include "ops/resize_bilinear.h" #include "ops/resize_nearest_neighbor.h" #include "ops/sigmoid.h" +#include "ops/stack.h" #include "ops/tanh.h" using mindspore::ops::kNameAbs; @@ -89,6 +92,7 @@ using mindspore::ops::kNameLeakyRelu; using mindspore::ops::kNameMaxPool; using mindspore::ops::kNameMul; using mindspore::ops::kNamePad; +using mindspore::ops::kNamePow; using mindspore::ops::kNamePReLU; using mindspore::ops::kNameReduceAll; using mindspore::ops::kNameReduceASum; @@ -115,6 +119,7 @@ namespace { constexpr auto kNameArgMaxWithValue = "ArgMaxWithValue"; constexpr auto kNameArgMinWithValue = "ArgMinWithValue"; constexpr auto kNameBatchMatMul = "BatchMatMul"; +constexpr auto kNameSlice = "Slice"; constexpr auto kNameGatherV2 = "Gather"; constexpr auto kNameTensorAdd = "TensorAdd"; std::map activation_map = { @@ -418,6 +423,30 @@ int MoveAttrMapResize(const CNodePtr &cnode) { } } // namespace +int MoveAttrSlice(const CNodePtr &cnode) { + MS_ASSERT(value_node != nullptr); + auto value_node = cnode->input(0)->cast(); + MS_ASSERT(value_node != nullptr); + auto src_prim = GetValueNode(value_node); + if (src_prim == nullptr) { + MS_LOG(ERROR) << "value node is invalid."; + return lite::RET_ERROR; + } + auto dst_prim = std::make_shared(); + MS_ASSERT(dst_prim != nullptr); + auto begin = GetValueNode(cnode->input(2)); + auto begin_value = GetValue>(begin); + + std::vector axes(begin_value.size()); + for (size_t i = 0; i < begin_value.size(); i++) { + axes[i] = i; + } + dst_prim->set_axes(axes); + dst_prim->SetAttrs(src_prim->attrs()); + value_node->set_value(dst_prim); + return lite::RET_OK; +} + bool PrimitiveAdjustPass::Run(const FuncGraphPtr &func_graph) { if (this->fmk_type_ != lite::converter::FmkType_MS) { MS_LOG(INFO) << "The framework type of model should be mindir."; @@ -480,6 +509,7 @@ REGIST_PRIMITIVE_ADJUST(kNameLeakyRelu, MoveAttrMapActivation) REGIST_PRIMITIVE_ADJUST(kNameMaxPool, MoveAttrPool) REGIST_PRIMITIVE_ADJUST(kNameMul, MoveAttrMapCommon) REGIST_PRIMITIVE_ADJUST(kNamePad, MoveAttrMapCommon) +REGIST_PRIMITIVE_ADJUST(kNamePow, MoveAttrMapCommon) REGIST_PRIMITIVE_ADJUST(kNamePReLU, MoveAttrMapCommon) REGIST_PRIMITIVE_ADJUST(kNameReduceAll, MoveAttrMapReduce) REGIST_PRIMITIVE_ADJUST(kNameReduceASum, MoveAttrMapReduce) @@ -495,6 +525,7 @@ REGIST_PRIMITIVE_ADJUST(kNameResizeBilinear, MoveAttrMapResize) REGIST_PRIMITIVE_ADJUST(kNameResizeNearestNeighbor, MoveAttrMapResize) REGIST_PRIMITIVE_ADJUST(kNameScale, MoveAttrMapCommon) REGIST_PRIMITIVE_ADJUST(kNameSigmoid, MoveAttrMapActivation) +REGIST_PRIMITIVE_ADJUST(kNameSlice, MoveAttrSlice) REGIST_PRIMITIVE_ADJUST(kNameSub, MoveAttrMapCommon) REGIST_PRIMITIVE_ADJUST(kNameTanh, MoveAttrMapActivation) REGIST_PRIMITIVE_ADJUST(kNameTensorAdd, MoveAttrMapCommon)