diff --git a/mindspore/ccsrc/predict/converter/attr_utils/convert_util.h b/mindspore/ccsrc/predict/converter/attr_utils/convert_util.h index d29e5e532e..5c7551a190 100644 --- a/mindspore/ccsrc/predict/converter/attr_utils/convert_util.h +++ b/mindspore/ccsrc/predict/converter/attr_utils/convert_util.h @@ -36,7 +36,6 @@ using GraphDefT = mindspore::predict::GraphDefT; using TensorDefT = mindspore::predict::TensorDefT; using SubGraphDefT = mindspore::predict::SubGraphDefT; using SubGraphPtr = std::unique_ptr; -using NodeDef = mindspore::predict::NodeDefT; using MsDataType = mindspore::predict::DataType; using MsFormat = mindspore::predict::Format; using MsKernelKey = void *; diff --git a/mindspore/ccsrc/predict/converter/kernel2ms.cc b/mindspore/ccsrc/predict/converter/kernel2ms.cc index 32cdee1350..a1537fa3f0 100644 --- a/mindspore/ccsrc/predict/converter/kernel2ms.cc +++ b/mindspore/ccsrc/predict/converter/kernel2ms.cc @@ -108,8 +108,7 @@ bool Kernel2Ms::SetGraphOutputIdx(const KernelGraphPtr &kernel_graph_ptr, const } bool Kernel2Ms::SetOpOutputIdx(const CNodePtr &c_node_ptr, const TensorPtr &output_tensor, - const TensorCachePtr &tensor_cache, int ref_count, size_t order_index, - NodeDef *ms_node) { + const TensorCachePtr &tensor_cache, int ref_count, size_t order_index, OpDefT *ms_node) { MS_EXCEPTION_IF_NULL(c_node_ptr); MS_EXCEPTION_IF_NULL(output_tensor); MS_EXCEPTION_IF_NULL(ms_node); @@ -123,7 +122,7 @@ bool Kernel2Ms::SetOpOutputIdx(const CNodePtr &c_node_ptr, const TensorPtr &outp std::vector tensor_shape; (void)std::transform(host_shape.begin(), host_shape.end(), std::back_inserter(tensor_shape), SizeToInt); int outputIndex = tensor_cache->addExTensor(tensor_key, output_tensor, ref_count, tensor_shape, KERNEL); - ms_node->opDef->outputIndex.push_back(outputIndex); + ms_node->outputIndex.push_back(outputIndex); return true; } @@ -164,7 +163,7 @@ void Kernel2Ms::GetRealInpoutsPtr(const AnfNodePtr &node, std::vectoropDef->inputIndex.push_back(ex_tensor_ptr->index_); + ms_node->inputIndex.push_back(ex_tensor_ptr->index_); } } return true; @@ -397,19 +396,18 @@ bool Kernel2Ms::SetGraphOpTensors(const KernelGraphPtr &kernel_graph_ptr, const return false; } auto kernel_key = node_indexs_[kernel.get()]; - std::unique_ptr ms_node(new NodeDef); + std::unique_ptr ms_node(new OpDefT); + ms_node->name = kernel->fullname_with_scope(); ms_node->fmkType = mindspore::predict::FmkType_CAFFE; - std::unique_ptr ms_op(new OpDefT()); auto c_name = AnfAlgo::GetCNodeName(kernel); auto fun = predict::convert::OpAttrFactory::GetInstance()->GetPackFun(c_name); if (fun == nullptr) { MS_LOG(ERROR) << "get node [" << kernel->fullname_with_scope() << "] attr failed."; return false; - } else if (!fun(kernel, ms_op.get())) { + } else if (!fun(kernel, ms_node.get())) { MS_LOG(ERROR) << "set node [" << kernel->fullname_with_scope() << "] attr failed."; return false; } - ms_node->opDef = std::move(ms_op); auto output_size = AnfAlgo::GetOutputTensorNum(kernel); int nodeRefCount = SizeToInt(output_size); for (size_t j = 0; j < output_size; ++j) { @@ -466,7 +464,7 @@ bool Kernel2Ms::KernelGraph2MsGraph(const KernelGraphPtr &kernel_graph_ptr) { if (!SetOpInputIdx(kernels[i], tensor_cache_ptr_, ms_node)) { return false; } - std::unique_ptr ms_node_tmp(ms_node); + std::unique_ptr ms_node_tmp(ms_node); sub_ms_graph->nodes.emplace_back(std::move(ms_node_tmp)); } if (!SetAllTensors(tensor_cache_ptr_, sub_ms_graph.get())) { diff --git a/mindspore/ccsrc/predict/converter/kernel2ms.h b/mindspore/ccsrc/predict/converter/kernel2ms.h index f991ecc94a..7013f88107 100644 --- a/mindspore/ccsrc/predict/converter/kernel2ms.h +++ b/mindspore/ccsrc/predict/converter/kernel2ms.h @@ -64,10 +64,10 @@ class Kernel2Ms { bool SetAllTensors(const TensorCachePtr &tensor_cache, SubGraphDefT *sub_graph_def_t); - bool SetOpInputIdx(const CNodePtr &c_node_ptr, const TensorCachePtr &tensor_cache, NodeDef *ms_node); + bool SetOpInputIdx(const CNodePtr &c_node_ptr, const TensorCachePtr &tensor_cache, OpDefT *ms_node); bool SetOpOutputIdx(const CNodePtr &c_node_ptr, const TensorPtr &output_tensor, const TensorCachePtr &tensor_cache, - int ref_count, size_t order_index, NodeDef *ms_node); + int ref_count, size_t order_index, OpDefT *ms_node); bool SetGraphOutputIdx(const KernelGraphPtr &kernel_graph_ptr, const TensorCachePtr &tensor_cache, SubGraphDefT *sub_graph_def_t, AllOutputTensors *all_output_tensors); @@ -102,7 +102,7 @@ class Kernel2Ms { bool SetMemResue() const; SubGraphPtr sub_ms_graph_; AllOutputTensors all_output_tensors_; - std::vector tmp_op_nodes_; + std::vector tmp_op_nodes_; std::unordered_map node_indexs_; std::unordered_map index_nodes_; int graph_index_ = 0; diff --git a/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.cc index e6fec3d540..932b5928fa 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.cc +++ b/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.cc @@ -33,6 +33,14 @@ bool CastPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); bool MeanPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); bool SoftmaxPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); bool ScalePacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool AddFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool ArgMaxPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool BatchNormFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool FakeQuantWithMinMaxPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool FakeQuantWithMinMaxPerChannelPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool MulPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool MulFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); +bool SqueezePacker(const CNodePtr &c_node_ptr, OpDefT *ms_op); OpAttrFactory::OpAttrFactory() { pack_funs_ = {{"Conv2D", Conv2dPacker}, @@ -60,23 +68,31 @@ OpAttrFactory::OpAttrFactory() { {"TensorAdd", AddPacker}, {"SoftMax", SoftmaxPacker}, {"SimpleMean", MeanPacker}, - {"Scale", ScalePacker}}; + {"ReduceMean", MeanPacker}, + {"AddFold", AddFoldPacker}, + {"ArgMax", ArgMaxPacker}, + {"BatchNorm", BatchNormFoldPacker}, + {"FakeQuantWithMinMax", FakeQuantWithMinMaxPacker}, + {"FakeQuantWithMinMaxPerChannel", FakeQuantWithMinMaxPerChannelPacker}, + {"Mul", MulPacker}, + {"MulFold", MulFoldPacker}, + {"Squeeze", SqueezePacker}}; } OpAttrPackFun OpAttrFactory::GetPackFun(const std::string &opType) { if (pack_funs_.find(opType) == pack_funs_.end()) { - MS_LOG(ERROR) << "Op Attr pack fun [\" << opType << \"] not found."; + MS_LOG(WARNING) << "Op Attr pack fun [" << opType << "] not found."; return nullptr; } return pack_funs_[opType]; } -mindspore::predict::DataFormatType GetAttrFormat(const std::string &format) { +mindspore::predict::Format GetAttrFormat(const std::string &format) { if (format == kOpFormat_NCHW) { - return predict::DataFormatType::DataFormatType_NCHW; + return predict::Format::Format_NCHW; } else if (format == kOpFormat_NHWC) { - return predict::DataFormatType::DataFormatType_NHWC; + return predict::Format::Format_NHWC; } else { - return predict::DataFormatType::DataFormatType_UNKNOW; + return predict::Format::Format_NUM_OF_FORMAT; } } diff --git a/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.h b/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.h index 83d0f9287b..89e38d1871 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.h +++ b/mindspore/ccsrc/predict/converter/lite_model/op_attr_packer.h @@ -48,7 +48,7 @@ class OpAttrFactory { std::unordered_map pack_funs_; }; -mindspore::predict::DataFormatType GetAttrFormat(const std::string &format); +mindspore::predict::Format GetAttrFormat(const std::string &format); mindspore::predict::PadMode GetAttrPadMode(const std::string &pad_mode); } // namespace convert diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/add_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/add_packer.cc index 81a2d3a9af..02a9bda65e 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/operations/add_packer.cc +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/add_packer.cc @@ -25,7 +25,6 @@ bool AddPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { } std::unique_ptr attr(new AddT()); MS_EXCEPTION_IF_NULL(attr); - attr->format = predict::DataFormatType::DataFormatType_NCHW; ms_op->name = c_node_ptr->fullname_with_scope(); ms_op->attr.type = OpT_Add; ms_op->attr.value = attr.release(); diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/addfold_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/addfold_packer.cc new file mode 100644 index 0000000000..b6affd5001 --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/addfold_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool AddFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new AddFoldT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_AddFold; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/argmax_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/argmax_packer.cc new file mode 100644 index 0000000000..4df643704c --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/argmax_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool ArgMaxPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new ArgMaxT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_ArgMax; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/batchnormfold_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/batchnormfold_packer.cc new file mode 100644 index 0000000000..f05f3894be --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/batchnormfold_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool BatchNormFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new BatchNormFoldT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_BatchNormFold; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmax_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmax_packer.cc new file mode 100644 index 0000000000..195a4fde9f --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmax_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool FakeQuantWithMinMaxPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new FakeQuantWithMinMaxT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_FakeQuantWithMinMax; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmaxperchannel_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmaxperchannel_packer.cc new file mode 100644 index 0000000000..0074c87646 --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/fakequantwithminmaxperchannel_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool FakeQuantWithMinMaxPerChannelPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new FakeQuantWithMinMaxPerChannelT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_FakeQuantWithMinMaxPerChannel; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/mul_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/mul_packer.cc new file mode 100644 index 0000000000..6c430e79e7 --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/mul_packer.cc @@ -0,0 +1,34 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool MulPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new MulT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->attr.type = OpT_Mul; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/mulflod_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/mulflod_packer.cc new file mode 100644 index 0000000000..1df7204875 --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/mulflod_packer.cc @@ -0,0 +1,35 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool MulFoldPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new MulFoldT()); + MS_EXCEPTION_IF_NULL(attr); + ms_op->name = c_node_ptr->fullname_with_scope(); + ms_op->attr.type = OpT_MulFold; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/pooling_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/pooling_packer.cc index 4eeb643817..edfdcda040 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/operations/pooling_packer.cc +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/pooling_packer.cc @@ -36,7 +36,6 @@ bool PoolingPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { attr->poolingMode = mindspore::predict::PoolMode::PoolMode_MEAN_POOLING; } else if (c_name == "GlobalPool") { ms_op->name = c_node_ptr->fullname_with_scope(); - attr->poolingMode = mindspore::predict::PoolMode::PoolMode_GLOBAL_POOING; } else { MS_LOG(ERROR) << "unknowed pooling type."; return false; @@ -53,7 +52,6 @@ bool PoolingPacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { attr->padDown = 0; attr->padLeft = 0; attr->padRight = 0; - attr->caffeMode = false; ms_op->attr.type = OpT_Pooling; ms_op->attr.value = attr.release(); return true; diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/reshape_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/reshape_packer.cc index cd8b72a8ac..a0a263631d 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/operations/reshape_packer.cc +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/reshape_packer.cc @@ -25,7 +25,7 @@ bool ReshapePacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { } std::unique_ptr attr(new ReshapeT()); MS_EXCEPTION_IF_NULL(attr); - attr->format = predict::DataFormatType::DataFormatType_NCHW; + attr->format = predict::Format::Format_NCHW; ms_op->name = c_node_ptr->fullname_with_scope(); ms_op->attr.type = OpT_Reshape; ms_op->attr.value = attr.release(); diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/scale_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/scale_packer.cc index 7b4f6f6283..356775247d 100644 --- a/mindspore/ccsrc/predict/converter/lite_model/operations/scale_packer.cc +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/scale_packer.cc @@ -25,7 +25,7 @@ bool ScalePacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { } std::unique_ptr attr(new ScaleT()); MS_EXCEPTION_IF_NULL(attr); - attr->format = predict::DataFormatType::DataFormatType_NCHW; + attr->format = predict::Format::Format_NCHW; ms_op->name = c_node_ptr->fullname_with_scope(); ms_op->attr.type = OpT_Scale; ms_op->attr.value = attr.release(); diff --git a/mindspore/ccsrc/predict/converter/lite_model/operations/squeeze_packer.cc b/mindspore/ccsrc/predict/converter/lite_model/operations/squeeze_packer.cc new file mode 100644 index 0000000000..7e836fe021 --- /dev/null +++ b/mindspore/ccsrc/predict/converter/lite_model/operations/squeeze_packer.cc @@ -0,0 +1,38 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "predict/converter/lite_model/op_attr_packer.h" + +namespace mindspore { +namespace predict { +namespace convert { +bool SqueezePacker(const CNodePtr &c_node_ptr, OpDefT *ms_op) { + if (c_node_ptr == nullptr || ms_op == nullptr) { + return false; + } + std::unique_ptr attr(new SqueezeT()); + MS_EXCEPTION_IF_NULL(attr); + + std::vector kernel_axis_value = AnfAlgo::GetNodeAttr>(c_node_ptr, "axis"); + attr->axis = kernel_axis_value; + + ms_op->attr.type = OpT_Squeeze; + ms_op->attr.value = attr.release(); + return true; +} +} // namespace convert +} // namespace predict +} // namespace mindspore diff --git a/mindspore/ccsrc/predict/predict.cc b/mindspore/ccsrc/predict/predict.cc index d81dcd3321..8310fc4028 100644 --- a/mindspore/ccsrc/predict/predict.cc +++ b/mindspore/ccsrc/predict/predict.cc @@ -22,7 +22,7 @@ namespace mindspore { namespace predictmodel { -void StepConvertGraph(const KernelGraphPtrNew &kernel_graph_ptr) { +void StepConvertGraph(const KernelGraphPtr &kernel_graph_ptr) { MS_LOG(INFO) << "start convert_graph step"; // get kernel_graph. this graph can be origin or device, depends on which steps to persistence MS_EXCEPTION_IF_NULL(kernel_graph_ptr); @@ -59,15 +59,5 @@ void StepConvertWeight(const std::vector &inputs) { } } } - -executor::TargetMode GetDeviceTarget(const std::string &device_target) { - if (device_target == "GPU") { - return executor::kGPUTarget; - } else if (device_target == "Ascend") { - return executor::kCPUTarget; - } else { - return executor::kUnknowTarget; - } -} } // namespace predictmodel } // namespace mindspore diff --git a/mindspore/ccsrc/predict/predict.h b/mindspore/ccsrc/predict/predict.h index 04184fe77c..7c65f16619 100644 --- a/mindspore/ccsrc/predict/predict.h +++ b/mindspore/ccsrc/predict/predict.h @@ -19,16 +19,14 @@ #include #include -#include #include "session/session_basic.h" #include "predict/converter/kernel2ms.h" namespace mindspore { namespace predictmodel { -using KernelGraphPtrNew = std::shared_ptr; -void StepConvertGraph(const KernelGraphPtrNew &kernel_graph_ptr); +using KernelGraphPtr = std::shared_ptr; +void StepConvertGraph(const KernelGraphPtr &kernel_graph_ptr); void StepConvertWeight(const std::vector &inputs); -executor::TargetMode GetDeviceTarget(const std::string &device_target); } // namespace predictmodel } // namespace mindspore #endif // MINDSPORE_MINDSPORE_CCSRC_PREDICT_H_ diff --git a/mindspore/ccsrc/predict/schema/ms.fbs b/mindspore/ccsrc/predict/schema/ms.fbs index a114fc444e..7c3dcfb498 100644 --- a/mindspore/ccsrc/predict/schema/ms.fbs +++ b/mindspore/ccsrc/predict/schema/ms.fbs @@ -13,42 +13,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - + include "op.fbs"; namespace mindspore.predict; -enum DataType : int { - DT_FLOAT = 0, - DT_FLOAT16 = 1, - DT_INT8 = 2, - DT_INT32 = 3, - DT_UINT8 = 4, - DT_UINT32 = 8, - DT_UNDEFINED = 16 -} - -enum Format : int { - NCHW = 0, - NHWC, - NC4HW4 = 100, - NUM_OF_FORMAT -} - -enum MSConst: int { +enum MSCONST: int { WEIGHT_REFCOUNT = 999 } -table QuantizationDef { - // Quantized value q, corresponding float value r: - // r = scale * (q - zero_point), where scale = (rmax - rmin) / (qmax - qmin) - min: [float]; - max: [float]; - scale: [float]; - zero_point: [long]; +table QuantParam { + scale: double; + zeroPoint: int; + min: double = 0; + max: double = 0; + narrowRange: bool = true; + numBits: int = 8; +} - // Tensor shape of the specifies dimension. - dimension: int; +table QuantParamArray { + param: [QuantParam]; //pre-channel } table TensorDef { @@ -60,7 +44,6 @@ table TensorDef { refCount: int; offset: int; data: [ubyte]; - quantization: QuantizationDef; } union OpT { @@ -70,7 +53,6 @@ union OpT { Conv2D, FusedBatchNorm, CaffeBatchNorm, - Squeeze, BiasAdd, Pooling, DepthwiseConv2D, @@ -85,57 +67,134 @@ union OpT { Eltwise, NetOutput, Add, + Sub, MatMul, StridedSlice, Power, Slice, Stack, Mul, + RealDiv, Pad, Maximum, + Minimum, CaffePReLU, + LeakyReLU, ArgMax, + ArgMin, Exp, CaffeCrop, Range, + Rsqrt, ExpandDims, Tile, - Cast -// Split + Cast, + Shape, + Nchw2Nhwc, + Nhwc2Nchw, + QuantDTypeCast, + Split, + Permute, + FakeQuantWithMinMaxVars, + Equal, + Less, + Greater, + Min, + Floor, + Abs, + Neg, + Cos, + Sin, + Sqrt, + Square, + Constant, + Log, + Tan, + Atan, + Asin, + Clip, + Transpose, + Squeeze, + Unsqueeze, + Upsample, + Dropout, + Broadcast, + Lrn, + Prelu, + ZerosLike, + TopK, + SpaceToDepth, + SpaceToBatch, + SparseToDense, + ReverseSequence, + Rank, + Gather, + GatherNd, + Fill, + Elu, + DepthToSpace, + BatchToSpace, + AddN, + Ceil, + EmbeddingLookup, + EmbeddingLookupSparse, + FloorDiv, + FloorMod, + L2Norm, + LocalResponseNormalization, + MatrixDiag, + Reduce, + Reverse, + Round, + Select, + Scatter, + Unique, + Unstack, + LogicalAnd, + LogicalOr, + LogicalXor, + LogicalNot, + OnnxInt8Quantize, + OnnxInt8Dequantize, + FakeQuantWithMinMax, + FakeQuantWithMinMaxPerChannel, + BatchNormFold, + MulFold, + AddFold, + SquaredDifference } enum QuantType: int { QUANT_NONE, - QUANT_INT8 + AwareTrainning, + WeightQuant, + PostTraining +} + +enum FmkType: int { + TF, + CAFFE, + ONNX, + MS, + TFLITE } table OpDef { name: string; + fmkType: FmkType; attr: OpT; inputIndex: [uint]; outputIndex: [uint]; - isLastConv: bool; quantType: QuantType = QUANT_NONE; + quantParam: [QuantParamArray]; } - -enum FmkType: int { - TF, - CAFFE -} - -table NodeDef { - fmkType: FmkType; - opDef: OpDef; -} - - table SubGraphDef { name: string; inputIndex: [uint]; outputIndex: [uint]; mempoolSize: uint; - nodes: [NodeDef]; + nodes: [OpDef]; allTensors: [TensorDef]; // weight + input + output } diff --git a/mindspore/ccsrc/predict/schema/op.fbs b/mindspore/ccsrc/predict/schema/op.fbs index d48f11b4d1..9286c2b2d3 100644 --- a/mindspore/ccsrc/predict/schema/op.fbs +++ b/mindspore/ccsrc/predict/schema/op.fbs @@ -22,12 +22,30 @@ enum ResizeMethod: byte { NEAREST_NEIGHBOR = 1 } -enum DataFormatType : byte { // todo combine with mslite.h::Format - UNKNOW = -1, +enum DataType : int { + DT_FLOAT = 0, + DT_FLOAT16 = 1, + DT_INT8 = 2, + DT_INT32 = 3, + DT_UINT8 = 4, + DT_INT16 = 5, + DT_UINT32 = 8, + DT_INT64 = 9, + DT_UINT16 = 10, + DT_UNDEFINED = 16 +} + +enum Format : int { NCHW = 0, - NHWC = 1, - HWC = 2, // for input image or resize - CHW = 3, // for input image or resize + NHWC, + HWKC, + HWCK, + KCHW, + CKHW, + KHWC, + CHWK, + NC4HW4 = 100, + NUM_OF_FORMAT } enum ActivationType : byte { @@ -42,26 +60,47 @@ enum ActivationType : byte { SOFTSIGN = 8, SOFTPLUS = 9, TANH = 10, - UNKNOW = 11 + SELU = 11, + HSWISH = 12, + HSIGMOID = 13, + THRESHOLDRELU = 14, + LINEAR = 15, + UNKNOW = 16 +} + +enum ReduceType : byte { + REDUCE_MAX = 0, + REDUCE_MEAN = 1, + REDUCE_ALL = 2, + REDUCE_ANY = 3, + REDUCE_LOG_SUM_EXP = 4, + REDUCE_PROD = 5, + REDUCE_SUM = 6, + UNKNOW = 7 } enum PoolMode : byte { MAX_POOLING = 0, MEAN_POOLING = 1, - GLOBAL_POOING = 2 } enum EltwiseMode : byte { PROD = 0, SUM = 1, - MAXIMUM = 2 + MAXIMUM = 2, + UNKNOW = 3 } enum PadMode : byte { - NOTSET=0, - SAME=1, - VALID=2, - CAFFE_CEIL_NEW=4 + NOTSET = 0, + SAME = 1, + VALID = 2, + CAFFE = 4 +} + +enum RoundMode : byte { + FLOOR = 0, + CEIL = 1 } enum PaddingMode : byte { @@ -77,7 +116,9 @@ table Pad { } table Maximum { - format: DataFormatType = 0; +} + +table Minimum { } table Concat { @@ -94,7 +135,7 @@ table Activation { } table Conv2D { - format: DataFormatType = 0; + format: Format = 0; group: int; channelIn: int; channelOut: int; @@ -114,15 +155,29 @@ table Conv2D { } table FusedBatchNorm { - epsilon: float; // eg. epsilon=0.001 + epsilon: float = 0.00001; // eg. epsilon=0.001 + momentum: float = 0.9; + spatial: int = 1; } table CaffeBatchNorm { epsilon: float; // eg. epsilon=0.001 } -table Squeeze { - axis: [int]; +table Shape { +} + +table Nchw2Nhwc { + +} + +table Nhwc2Nchw { + +} + +table FakeQuantWithMinMaxVars { + narrowRange: bool; + numBits: int; } table BiasAdd { @@ -130,8 +185,9 @@ table BiasAdd { } table Pooling { - format: DataFormatType = 0; + format: Format = 0; poolingMode: PoolMode; + global: bool = false; windowW: int; windowH: int; strideW: int; @@ -141,12 +197,11 @@ table Pooling { padDown: int; padLeft: int; padRight: int; - // todo replace with padValueMode in convolution pooling and so on - caffeMode: bool = false; + roundMode: RoundMode; } table DepthwiseConv2D { - format: DataFormatType = 0; + format: Format = 0; channelIn: int; channelMultiplier: int; kernelW: int; @@ -165,7 +220,7 @@ table DepthwiseConv2D { } table DeDepthwiseConv2D { - format: DataFormatType = 0; + format: Format = 0; channelIn: int; channelMultiplier: int; kernelW: int; @@ -185,7 +240,7 @@ table DeDepthwiseConv2D { table Resize { - format: DataFormatType = 0; + format: Format = 0; method: ResizeMethod; newHeight: long; newWidth: long; @@ -194,7 +249,7 @@ table Resize { } table DetectionPostProcess { - format: DataFormatType = 0; + format: Format = 0; inputSize: int; hScale: float; wScale: float; @@ -210,8 +265,8 @@ table DetectionPostProcess { } table FullConnection { - format: DataFormatType = 0; hasBias: bool; + axis: int; } // Mean(input_tensor, axis, keep_dims) @@ -221,7 +276,7 @@ table Mean { } table DeConv2D { - format: DataFormatType = 0; + format: Format = 0; group: int; channelIn: int; channelOut: int; @@ -241,34 +296,88 @@ table DeConv2D { } table Scale { - format: DataFormatType = 0; + format: Format = 0; } table Eltwise { - format: DataFormatType = 0; mode: EltwiseMode; - // todo repeat coeff (default 1) } table Add { - format: DataFormatType = 0; +} + +table Sub { +} + +table Mul { +} + +table RealDiv { +} + +table Rsqrt { +} + +table Equal { +} + +table Less { +} + +table Greater { +} + +table Min { } table Slice { - format: DataFormatType = 0; + format: Format = 0; begin: [int]; - end: [int]; - stride: [int]; + size: [int]; } -table Mul { +table Floor { +} + +table Abs { +} + +table Neg { } table Exp { } +table Cos { +} + +table Sin { +} + +table Sqrt { +} + +table Square { +} + +table Ceil { +} + +table Log { +} + +table Tan { +} + +table Atan { +} + +table Asin { +} + table Reshape { - format: DataFormatType = 0; + format: Format = 0; + shape: [long]; } table Power { @@ -280,13 +389,20 @@ table Power { table ArgMax { axis: int; outMaxValue: bool; - topK: int; + topK: int = 1; + keepDims: bool; + axisType: int; +} + +table ArgMin { + axis: int; + outMaxValue: bool; + topK: int = 1; keepDims: bool; axisType: int; } table NetOutput { - format: DataFormatType = 0; } table MatMul { @@ -298,6 +414,10 @@ table CaffePReLU { channelShared : bool = false; } +table LeakyReLU { + negativeSlope: float; +} + table StridedSlice { beginMask: int; endMask: int; @@ -317,6 +437,7 @@ table Stack { } table Range { + dType: DataType; start: int; limit: int; delta: int; @@ -335,13 +456,244 @@ table Cast { dstT: int; } -//table Split { -// numberSplit: int; -// sizeSplits: [int]; -// splitDim: int; -//} +table QuantDTypeCast { + srcT: DataType; + dstT: DataType; +} + +table Split { + numberSplit: int; + sizeSplits: [int]; + splitDim: int; +} table CaffeCrop { axis : long; offsets : [long]; } + +table Permute { + order: [long]; +} + +table Clip { + max: float; + min: float; +} + +table Constant { +} + + +table Elu { + alpha: float = 1.0; +} + +table Broadcast { +} + +table Lrn { + alpha: float = 0.0001; + beta: float = 0.75; + bias: float = 1.0; + size: int; +} + +enum ReduceMode : byte { + ReduceMean = 0, + ReduceMax = 1, + ReduceMin = 2, + ReduceProd = 3, + ReduceSum = 4, + ReduceSumSquare = 5 +} + +table Reduce { + axes: [int]; + keepDims: int; + mode: ReduceMode; +} + +table Prelu { + slope: [float]; +} + +table Transpose { + perm: [int]; + conjugate: bool = false; +} + +table Squeeze { + axis: [int]; +} + +table Unsqueeze { + axis: [int]; +} + +table Upsample { + mode: string; + scales: [float]; +} + +table Dropout { + ratio : float = 0.5; +} + +table LocalResponseNormalization { + depth_radius: int; + bias: float; + alpha: float; + beta: float; +} + +table ZerosLike { +} + +table TopK { + k : int; + sorted : bool = true; +} + +table SpaceToDepth { + blockSize : int; + format: Format = 0; +} + +table SpaceToBatch { + blockShape : [int]; + paddings : [int]; +} + +table SparseToDense { + validateIndices: bool; +} + +table ReverseSequence { + seqAxis: int; + batchAxis: int; +} + +table Rank { +} + + +table Gather { + axis: int; + batchDims: int; +} + +table GatherNd { + batchDims: int; +} + +table Fill { + dims: [int]; +} + +table DepthToSpace { + blockSize: int; + format: Format = 0; +} + + +table BatchToSpace { + blockShape: [int]; + crops: [int]; +} + +table AddN { + N: int; +} + + +table EmbeddingLookup { + ids: [int]; + maxNorm: float; +} + +table EmbeddingLookupSparse { + spIds: [int]; + spWeights: [float]; + //combiner: Combiner=0; + maxNortm: float; +} + +table FloorDiv { +} + +table FloorMod { +} + +table L2Norm { + axis: [int]; + epsilon: float; +} + +table LogicalAnd { +} + +table LogicalOr { +} + +table LogicalXor { +} + +table LogicalNot { +} + +table MatrixDiag { + k: int; + numRows: int; + numCols: int; + paddingValue: float; +} + +table Select { +} + +table TfReduce { + type: ReduceType = 7; +} + +table Reverse { + axis: [int]; +} + +table Round { +} + +table Scatter { +} + +table Unique { +} + +table Unstack { + num: int; + axis: int; +} + +table OnnxInt8Quantize { +} + +table OnnxInt8Dequantize { +} + +table FakeQuantWithMinMax { +} + +table FakeQuantWithMinMaxPerChannel { +} + +table BatchNormFold { +} + +table MulFold { +} + +table AddFold { +} + +table SquaredDifference { +}