From 60af4c075a1d0f32d0e75fe52e0aa511169158cd Mon Sep 17 00:00:00 2001 From: yefeng Date: Sat, 21 Nov 2020 14:34:14 +0800 Subject: [PATCH] clean_sec_5 --- mindspore/lite/src/common/file_utils.cc | 20 ++++----- mindspore/lite/src/common/log_adapter.cc | 4 +- mindspore/lite/src/common/utils.cc | 42 +++++++++---------- mindspore/lite/src/common/utils.h | 4 +- mindspore/lite/src/kernel_registry.cc | 2 +- mindspore/lite/src/kernel_registry.h | 2 +- mindspore/lite/src/lite_kernel.cc | 12 +++--- mindspore/lite/src/lite_kernel.h | 14 +++---- mindspore/lite/src/lite_session.cc | 2 +- mindspore/lite/src/model_common.cc | 2 +- mindspore/lite/src/ops/adam.cc | 2 +- mindspore/lite/src/ops/addn.cc | 4 +- mindspore/lite/src/ops/apply_momentum.cc | 2 +- mindspore/lite/src/ops/argmax.cc | 4 +- mindspore/lite/src/ops/argmin.cc | 4 +- mindspore/lite/src/ops/arithmetic.cc | 8 ++-- mindspore/lite/src/ops/arithmetic_self.cc | 4 +- mindspore/lite/src/ops/assign.cc | 2 +- mindspore/lite/src/ops/assign_add.cc | 2 +- mindspore/lite/src/ops/audio_spectrogram.cc | 4 +- mindspore/lite/src/ops/batch_to_space.cc | 6 +-- mindspore/lite/src/ops/bias_grad.cc | 2 +- .../lite/src/ops/binary_cross_entropy.cc | 2 +- .../lite/src/ops/binary_cross_entropy_grad.cc | 2 +- mindspore/lite/src/ops/bn_grad.cc | 6 +-- mindspore/lite/src/ops/broadcast_to.cc | 4 +- mindspore/lite/src/ops/cast.cc | 4 +- mindspore/lite/src/ops/concat.cc | 4 +- mindspore/lite/src/ops/constant_of_shape.cc | 4 +- mindspore/lite/src/ops/conv2d.cc | 10 ++--- mindspore/lite/src/ops/conv2d_grad_filter.cc | 6 +-- mindspore/lite/src/ops/conv2d_grad_input.cc | 6 +-- mindspore/lite/src/ops/crop.cc | 4 +- .../lite/src/ops/custom_extract_features.cc | 4 +- mindspore/lite/src/ops/custom_normalize.cc | 2 +- mindspore/lite/src/ops/custom_predict.cc | 4 +- mindspore/lite/src/ops/deconv2d.cc | 8 ++-- mindspore/lite/src/ops/dedepthwise_conv2d.cc | 4 +- mindspore/lite/src/ops/depth_to_space.cc | 6 +-- mindspore/lite/src/ops/depthwise_conv2d.cc | 10 ++--- .../lite/src/ops/detection_post_process.cc | 10 ++--- mindspore/lite/src/ops/embedding_lookup.cc | 4 +- mindspore/lite/src/ops/equal.cc | 2 +- mindspore/lite/src/ops/expand_dims.cc | 4 +- mindspore/lite/src/ops/fft_imag.cc | 4 +- mindspore/lite/src/ops/fft_real.cc | 4 +- mindspore/lite/src/ops/fill.cc | 4 +- mindspore/lite/src/ops/flatten.cc | 4 +- mindspore/lite/src/ops/flatten_grad.cc | 4 +- mindspore/lite/src/ops/full_connection.cc | 4 +- mindspore/lite/src/ops/fused_batchnorm.cc | 4 +- mindspore/lite/src/ops/gather.cc | 4 +- mindspore/lite/src/ops/gather_nd.cc | 4 +- mindspore/lite/src/ops/greater.cc | 2 +- mindspore/lite/src/ops/greater_equal.cc | 2 +- .../lite/src/ops/group_conv2d_grad_input.cc | 6 +-- mindspore/lite/src/ops/hashtable_lookup.cc | 4 +- mindspore/lite/src/ops/layer_norm.cc | 4 +- mindspore/lite/src/ops/less.cc | 2 +- mindspore/lite/src/ops/less_equal.cc | 2 +- mindspore/lite/src/ops/lsh_projection.cc | 2 +- mindspore/lite/src/ops/lstm.cc | 4 +- mindspore/lite/src/ops/matmul.cc | 4 +- mindspore/lite/src/ops/mean.cc | 4 +- mindspore/lite/src/ops/mfcc.cc | 4 +- mindspore/lite/src/ops/nchw2nhwc.cc | 4 +- mindspore/lite/src/ops/nhwc2nchw.cc | 4 +- mindspore/lite/src/ops/non_max_suppression.cc | 2 +- mindspore/lite/src/ops/not_equal.cc | 2 +- mindspore/lite/src/ops/one_hot.cc | 4 +- mindspore/lite/src/ops/oneslike.cc | 2 +- mindspore/lite/src/ops/pad.cc | 4 +- mindspore/lite/src/ops/pooling.cc | 4 +- mindspore/lite/src/ops/pooling_grad.cc | 2 +- mindspore/lite/src/ops/power.cc | 4 +- mindspore/lite/src/ops/primitive_c.cc | 37 ++++++++-------- mindspore/lite/src/ops/primitive_c.h | 38 ++++++++--------- mindspore/lite/src/ops/prior_box.cc | 4 +- mindspore/lite/src/ops/quant_dtype_cast.cc | 4 +- mindspore/lite/src/ops/range.cc | 4 +- mindspore/lite/src/ops/rank.cc | 4 +- mindspore/lite/src/ops/reduce.cc | 8 ++-- mindspore/lite/src/ops/reshape.cc | 8 ++-- mindspore/lite/src/ops/resize.cc | 8 ++-- mindspore/lite/src/ops/return.cc | 6 +-- mindspore/lite/src/ops/reverse_sequence.cc | 4 +- mindspore/lite/src/ops/rfft.cc | 4 +- mindspore/lite/src/ops/roi_pooling.cc | 4 +- mindspore/lite/src/ops/scatter_nd.cc | 4 +- mindspore/lite/src/ops/sgd.cc | 2 +- mindspore/lite/src/ops/shape.cc | 4 +- mindspore/lite/src/ops/skip_gram.cc | 2 +- mindspore/lite/src/ops/slice.cc | 10 ++--- mindspore/lite/src/ops/softmax.cc | 4 +- .../lite/src/ops/softmax_cross_entropy.cc | 4 +- mindspore/lite/src/ops/space_to_batch.cc | 6 +-- mindspore/lite/src/ops/space_to_batch_nd.cc | 6 +-- mindspore/lite/src/ops/space_to_depth.cc | 6 +-- mindspore/lite/src/ops/sparse_to_dense.cc | 4 +- mindspore/lite/src/ops/split.cc | 6 +-- mindspore/lite/src/ops/squeeze.cc | 4 +- mindspore/lite/src/ops/stack.cc | 4 +- mindspore/lite/src/ops/strided_slice.cc | 10 ++--- mindspore/lite/src/ops/tile.cc | 8 ++-- mindspore/lite/src/ops/topk.cc | 6 +-- mindspore/lite/src/ops/transpose.cc | 8 ++-- mindspore/lite/src/ops/unique.cc | 6 +-- .../lite/src/ops/unsorted_segment_sum.cc | 2 +- mindspore/lite/src/ops/unsqueeze.cc | 4 +- mindspore/lite/src/ops/unstack.cc | 4 +- mindspore/lite/src/ops/where.cc | 4 +- mindspore/lite/src/ops/while.cc | 2 +- mindspore/lite/src/ops/zeros_like.cc | 4 +- mindspore/lite/src/runtime/allocator.cc | 42 +++++++++---------- mindspore/lite/src/runtime/allocator.h | 10 ++--- .../kernel/arm/base/batch_to_space_base.cc | 2 +- .../kernel/arm/base/convolution_base.cc | 14 +++---- .../kernel/arm/base/depth_to_space_base.cc | 2 +- .../src/runtime/kernel/arm/base/dequant.cc | 2 +- .../src/runtime/kernel/arm/base/dequant.h | 16 +++---- .../arm/base/detection_post_process_base.cc | 2 +- .../kernel/arm/base/fullconnection_base.cc | 4 +- .../runtime/kernel/arm/base/pooling_base.cc | 4 +- .../kernel/arm/base/quant_dtype_cast.cc | 11 +++-- .../kernel/arm/fp16/arithmetic_fp16.cc | 4 +- .../arm/fp16/convolution_depthwise_fp16.cc | 4 +- .../kernel/arm/fp16/convolution_fp16.cc | 10 ++--- .../arm/fp16/deconvolution_depthwise_fp16.cc | 4 +- .../kernel/arm/fp16/deconvolution_fp16.cc | 4 +- .../kernel/arm/fp16/fullconnection_fp16.cc | 4 +- .../kernel/arm/fp16/group_convolution_fp16.cc | 4 +- .../runtime/kernel/arm/fp16/matmul_fp16.cc | 4 +- .../kernel/arm/fp16/quant_dtype_cast_fp16.cc | 6 +-- .../kernel/arm/fp32/arithmetic_fp32.cc | 4 +- .../kernel/arm/fp32/convolution_fp32.cc | 10 ++--- .../arm/fp32/deconvolution_depthwise_fp32.cc | 4 +- .../kernel/arm/fp32/deconvolution_fp32.cc | 4 +- .../kernel/arm/fp32/depth_to_space_fp32.cc | 2 +- .../kernel/arm/fp32/group_convolution_fp32.cc | 4 +- .../runtime/kernel/arm/fp32/matmul_fp32.cc | 4 +- .../kernel/arm/fp32/space_to_batch_fp32.cc | 2 +- .../kernel/arm/fp32/space_to_depth_fp32.cc | 4 +- .../src/runtime/kernel/arm/int8/add_int8.cc | 12 +++--- .../runtime/kernel/arm/int8/argminmax_int8.cc | 4 +- .../kernel/arm/int8/arithmetic_int8.cc | 6 +-- .../kernel/arm/int8/arithmetic_self_int8.cc | 4 +- .../kernel/arm/int8/batch_to_space_int8.cc | 4 +- .../runtime/kernel/arm/int8/batchnorm_int8.cc | 40 +++++++++--------- .../runtime/kernel/arm/int8/concat_int8.cc | 4 +- .../arm/int8/convolution_depthwise_int8.cc | 7 ++-- .../convolution_depthwise_slidewindow_int8.cc | 18 ++++---- .../src/runtime/kernel/arm/int8/crop_int8.cc | 4 +- .../kernel/arm/int8/depth_to_space_int8.cc | 4 +- .../arm/int8/detection_post_process_int8.cc | 4 +- .../src/runtime/kernel/arm/int8/div_int8.cc | 12 +++--- .../kernel/arm/int8/fullconnection_int8.cc | 6 +-- .../runtime/kernel/arm/int8/gatherNd_int8.cc | 6 +-- .../runtime/kernel/arm/int8/gather_int8.cc | 4 +- .../runtime/kernel/arm/int8/hswish_int8.cc | 8 ++-- .../runtime/kernel/arm/int8/l2_norm_int8.cc | 8 ++-- .../kernel/arm/int8/layer_norm_int8.cc | 12 +++--- .../kernel/arm/int8/leaky_relu_int8.cc | 4 +- .../runtime/kernel/arm/int8/matmul_int8.cc | 6 +-- .../src/runtime/kernel/arm/int8/mul_int8.cc | 12 +++--- .../src/runtime/kernel/arm/int8/pad_int8.cc | 4 +- .../src/runtime/kernel/arm/int8/power_int8.cc | 6 +-- .../runtime/kernel/arm/int8/reduce_int8.cc | 8 ++-- .../src/runtime/kernel/arm/int8/relux_int8.cc | 8 ++-- .../runtime/kernel/arm/int8/reshape_int8.cc | 4 +- .../runtime/kernel/arm/int8/resize_int8.cc | 8 ++-- .../src/runtime/kernel/arm/int8/scale_int8.cc | 16 +++---- .../runtime/kernel/arm/int8/sigmoid_int8.cc | 8 ++-- .../src/runtime/kernel/arm/int8/slice_int8.cc | 4 +- .../runtime/kernel/arm/int8/softmax_int8.cc | 4 +- .../kernel/arm/int8/space_to_batch_int8.cc | 4 +- .../src/runtime/kernel/arm/int8/split_int8.cc | 4 +- .../runtime/kernel/arm/int8/squeeze_int8.cc | 4 +- .../src/runtime/kernel/arm/int8/sub_int8.cc | 12 +++--- .../runtime/kernel/arm/int8/unsqueeze_int8.cc | 4 +- .../src/runtime/kernel/opencl/kernel/scale.cc | 10 ++--- .../kernel/opencl/subgraph_opencl_kernel.cc | 16 +++---- .../lite/src/runtime/parallel_executor.cc | 2 +- mindspore/lite/src/scheduler.cc | 4 +- mindspore/lite/src/sub_graph_kernel.cc | 6 +-- mindspore/lite/src/tensor.cc | 30 ++++++------- mindspore/lite/src/tensor.h | 10 ++--- .../fp32/convolution_depthwise_fp32_tests.cc | 4 +- .../arm/fp32/detection_post_process_test.cc | 14 +++---- .../kernel/arm/fp32/l2norm_fp32_test.cc | 2 +- .../kernel/arm/fp32/lstm_fp32_tests.cc | 28 ++++++------- .../fp32/non_max_suppression_fp32_tests.cc | 4 +- .../runtime/kernel/arm/fp32/pad_fp32_test.cc | 2 +- .../arm/fp32/resize_bilinear_fp32_tests.cc | 2 +- .../kernel/arm/fp32/scale_fp32_tests.cc | 6 +-- .../arm/fp32/space_to_depth_fp32_tests.cc | 4 +- .../kernel/arm/fp32/transpose_fp32_tests.cc | 4 +- .../kernel/arm/int8/quant_dtype_cast_tests.cc | 4 +- .../runtime/kernel/arm/string/normalize.cc | 4 +- .../lite/tools/anf_exporter/anf_exporter.cc | 8 ++-- .../legacy_optimizer/graph/infershape_pass.cc | 2 +- .../quantizer/post_training_quantizer.cc | 28 ++++++------- .../tools/converter/quantizer/quant_cast.cc | 10 ++--- .../tools/converter/quantizer/quantize_util.h | 2 +- .../converter/quantizer/weight_quantizer.cc | 4 +- .../optimizer/fusion/batchmatmul_fusion.cc | 14 +++---- .../fusion/constant_folding_fusion.cc | 8 ++-- .../graph/clip_convert_activation_pass.cc | 2 +- .../unused_transpose_node_remove_pass.cc | 4 +- 208 files changed, 670 insertions(+), 669 deletions(-) diff --git a/mindspore/lite/src/common/file_utils.cc b/mindspore/lite/src/common/file_utils.cc index 8b25f0dbd6..760399fee1 100644 --- a/mindspore/lite/src/common/file_utils.cc +++ b/mindspore/lite/src/common/file_utils.cc @@ -28,15 +28,15 @@ char *ReadFile(const char *file, size_t *size) { return nullptr; } MS_ASSERT(size != nullptr); - std::string realPath = RealPath(file); - std::ifstream ifs(realPath); + std::string real_path = RealPath(file); + std::ifstream ifs(real_path); if (!ifs.good()) { - MS_LOG(ERROR) << "file: " << realPath << " is not exist"; + MS_LOG(ERROR) << "file: " << real_path << " is not exist"; return nullptr; } if (!ifs.is_open()) { - MS_LOG(ERROR) << "file: " << realPath << " open failed"; + MS_LOG(ERROR) << "file: " << real_path << " open failed"; return nullptr; } @@ -44,7 +44,7 @@ char *ReadFile(const char *file, size_t *size) { *size = ifs.tellg(); std::unique_ptr buf(new (std::nothrow) char[*size]); if (buf == nullptr) { - MS_LOG(ERROR) << "malloc buf failed, file: " << realPath; + MS_LOG(ERROR) << "malloc buf failed, file: " << real_path; ifs.close(); return nullptr; } @@ -65,21 +65,21 @@ std::string RealPath(const char *path) { MS_LOG(ERROR) << "path is too long"; return ""; } - auto resolvedPath = std::make_unique(PATH_MAX); - if (resolvedPath == nullptr) { + auto resolved_path = std::make_unique(PATH_MAX); + if (resolved_path == nullptr) { MS_LOG(ERROR) << "new resolvedPath failed"; return ""; } #ifdef _WIN32 - char *real_path = _fullpath(resolvedPath.get(), path, 1024); + char *real_path = _fullpath(resolved_path.get(), path, 1024); #else - char *real_path = realpath(path, resolvedPath.get()); + char *real_path = realpath(path, resolved_path.get()); #endif if (real_path == nullptr || strlen(real_path) == 0) { MS_LOG(ERROR) << "file path is not valid : " << path; return ""; } - std::string res = resolvedPath.get(); + std::string res = resolved_path.get(); return res; } } // namespace lite diff --git a/mindspore/lite/src/common/log_adapter.cc b/mindspore/lite/src/common/log_adapter.cc index 9253ffc379..d6fd2a1c02 100644 --- a/mindspore/lite/src/common/log_adapter.cc +++ b/mindspore/lite/src/common/log_adapter.cc @@ -26,7 +26,7 @@ namespace mindspore { constexpr const char *ANDROID_LOG_TAG = "MS_LITE"; -int EnvToInt(const char *env) { +int StrToInt(const char *env) { if (env == nullptr) return 2; if (strcmp(env, "0") == 0) return 0; if (strcmp(env, "1") == 0) return 1; @@ -37,7 +37,7 @@ int EnvToInt(const char *env) { bool IsPrint(int level) { static const char *env = std::getenv("GLOG_v"); - static int ms_level = EnvToInt(env); + static int ms_level = StrToInt(env); if (level < 0) { level = 2; } diff --git a/mindspore/lite/src/common/utils.cc b/mindspore/lite/src/common/utils.cc index cef0f0cf36..82f92f7823 100644 --- a/mindspore/lite/src/common/utils.cc +++ b/mindspore/lite/src/common/utils.cc @@ -48,24 +48,24 @@ uint64_t GetTimeUs() { return 0; } // USECS_IN_SEC *NSECS_IN_USEC; - auto retval = static_cast((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC)); - return retval; + auto ret_val = static_cast((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC)); + return ret_val; } -std::string Remove(const std::string &from, const std::string &subStr, Mode mode) { +std::string RemoveSubStr(const std::string &from, const std::string &sub_str, RemoveSubStrMode mode) { std::string result = from; if (mode == PREFIX) { - if (from.substr(0, subStr.length()) == subStr) { - result = from.substr(subStr.size()); + if (from.substr(0, sub_str.length()) == sub_str) { + result = from.substr(sub_str.size()); } } else if (mode == SUFFIX) { - if (from.rfind(subStr) == from.size() - subStr.size()) { - result = from.substr(0, from.size() - subStr.size()); + if (from.rfind(sub_str) == from.size() - sub_str.size()) { + result = from.substr(0, from.size() - sub_str.size()); } } else { size_t index; - while ((index = result.find(subStr)) != std::string::npos) { - result = result.erase(index, subStr.size()); + while ((index = result.find(sub_str)) != std::string::npos) { + result = result.erase(index, sub_str.size()); } } @@ -75,13 +75,13 @@ std::string Remove(const std::string &from, const std::string &subStr, Mode mode std::vector StrSplit(const std::string &str, const std::string &pattern) { std::string::size_type pos; std::vector result; - std::string tmpStr(str + pattern); - std::string::size_type size = tmpStr.size(); + std::string tmp_str(str + pattern); + std::string::size_type size = tmp_str.size(); for (std::string::size_type i = 0; i < size; i++) { - pos = tmpStr.find(pattern, i); + pos = tmp_str.find(pattern, i); if (pos < size) { - std::string s = tmpStr.substr(i, pos - i); + std::string s = tmp_str.substr(i, pos - i); result.push_back(s); i = pos + pattern.size() - 1; } @@ -90,8 +90,8 @@ std::vector StrSplit(const std::string &str, const std::string &pat } std::vector Tokenize(const std::string &src, const std::string &delimiters, - const Option &maxTokenNum) { - if (maxTokenNum.IsSome() && maxTokenNum.Get() == 0) { + const Option &max_token_num) { + if (max_token_num.IsSome() && max_token_num.Get() == 0) { return {}; } @@ -99,17 +99,17 @@ std::vector Tokenize(const std::string &src, const std::string &del size_t offset = 0; while (true) { - size_t nonDelimiter = src.find_first_not_of(delimiters, offset); - if (nonDelimiter == std::string::npos) { + size_t non_delimiter = src.find_first_not_of(delimiters, offset); + if (non_delimiter == std::string::npos) { break; } - size_t delimiter = src.find_first_of(delimiters, nonDelimiter); - if (delimiter == std::string::npos || (maxTokenNum.IsSome() && tokens.size() == maxTokenNum.Get() - 1)) { - tokens.push_back(src.substr(nonDelimiter)); + size_t delimiter = src.find_first_of(delimiters, non_delimiter); + if (delimiter == std::string::npos || (max_token_num.IsSome() && tokens.size() == max_token_num.Get() - 1)) { + tokens.push_back(src.substr(non_delimiter)); break; } - tokens.push_back(src.substr(nonDelimiter, delimiter - nonDelimiter)); + tokens.push_back(src.substr(non_delimiter, delimiter - non_delimiter)); offset = delimiter; } return tokens; diff --git a/mindspore/lite/src/common/utils.h b/mindspore/lite/src/common/utils.h index 47dad28dc3..46c090fecd 100644 --- a/mindspore/lite/src/common/utils.h +++ b/mindspore/lite/src/common/utils.h @@ -149,10 +149,10 @@ std::vector StrSplit(const std::string &str, const std::string &pat std::vector Tokenize(const std::string &src, const std::string &delimiters, const Option &maxTokenNum = Option(None())); -enum Mode { PREFIX, SUFFIX, ANY }; +enum RemoveSubStrMode { PREFIX, SUFFIX, ANY }; // remove redundant charactor -std::string Remove(const std::string &from, const std::string &subStr, Mode mode = ANY); +std::string RemoveSubStr(const std::string &from, const std::string &sub_str, RemoveSubStrMode mode = ANY); template inline Option GenericParseValue(const std::string &value) { diff --git a/mindspore/lite/src/kernel_registry.cc b/mindspore/lite/src/kernel_registry.cc index 30c5dc1ec6..4dcc1ee116 100644 --- a/mindspore/lite/src/kernel_registry.cc +++ b/mindspore/lite/src/kernel_registry.cc @@ -95,7 +95,7 @@ void KernelRegistry::RegKernel(const KERNEL_ARCH arch, const TypeId data_type, c creator_arrays_[index] = creator; } -bool KernelRegistry::Merge(const std::unordered_map &newCreators) { return false; } +bool KernelRegistry::Merge(const std::unordered_map &new_creators) { return false; } const kernel::KernelCreator *KernelRegistry::GetCreatorArrays() { return creator_arrays_; } diff --git a/mindspore/lite/src/kernel_registry.h b/mindspore/lite/src/kernel_registry.h index e9840afb08..f4c27cd881 100644 --- a/mindspore/lite/src/kernel_registry.h +++ b/mindspore/lite/src/kernel_registry.h @@ -41,7 +41,7 @@ class KernelRegistry { int GetCreatorFuncIndex(kernel::KernelKey desc); void RegKernel(kernel::KernelKey desc, kernel::KernelCreator creator); void RegKernel(kernel::KERNEL_ARCH arch, TypeId data_type, schema::PrimitiveType type, kernel::KernelCreator creator); - bool Merge(const std::unordered_map &newCreators); + bool Merge(const std::unordered_map &new_creators); kernel::LiteKernel *GetKernel(const std::vector &in_tensors, const std::vector &out_tensors, const PrimitiveC *primitive, const InnerContext *ctx, const kernel::KernelKey &key); diff --git a/mindspore/lite/src/lite_kernel.cc b/mindspore/lite/src/lite_kernel.cc index a0805dd2cd..a8e5e0fd71 100644 --- a/mindspore/lite/src/lite_kernel.cc +++ b/mindspore/lite/src/lite_kernel.cc @@ -26,7 +26,9 @@ using mindspore::lite::RET_OK; void *LiteKernel::workspace_ = nullptr; void LiteKernel::AllocWorkspace(size_t size) { - if (size == 0) return; + if (size == 0) { + return; + } workspace_ = malloc(size); if (workspace_ == nullptr) { MS_LOG(ERROR) << "fail to alloc " << size; @@ -74,10 +76,10 @@ int LiteKernel::FreeWorkTensor() const { int LiteKernel::PreProcess() { if (!InferShapeDone()) { - (const_cast(primitive_))->SetInferFlag(true); + (const_cast(primitive_))->set_infer_flag(true); auto ret = (const_cast(primitive_))->InferShape(in_tensors_, out_tensors_); if (ret != 0) { - (const_cast(primitive_))->SetInferFlag(false); + (const_cast(primitive_))->set_infer_flag(false); MS_LOG(ERROR) << "InferShape fail!"; return ret; } @@ -279,8 +281,8 @@ int LiteKernelUtil::TopologicalSortKernels(std::vector *ke void LiteKernelUtil::InitIOKernels(std::vector &kernels) { for (auto *kernel : kernels) { // clean io kernels - kernel->SetInKernel({}); - kernel->SetOutKernel({}); + kernel->set_in_kernels({}); + kernel->set_out_kernels({}); // find io kernels for (auto *search_kernel : kernels) { if (search_kernel == kernel) { diff --git a/mindspore/lite/src/lite_kernel.h b/mindspore/lite/src/lite_kernel.h index 8defe1be0d..712589b57b 100644 --- a/mindspore/lite/src/lite_kernel.h +++ b/mindspore/lite/src/lite_kernel.h @@ -136,9 +136,9 @@ class LiteKernel { } } - void SetInKernel(const std::vector &kernel) { this->in_kernels_ = kernel; } + void set_in_kernels(const std::vector &kernel) { this->in_kernels_ = kernel; } - void SetOutKernel(const std::vector &kernel) { this->out_kernels_ = kernel; } + void set_out_kernels(const std::vector &kernel) { this->out_kernels_ = kernel; } const std::vector &in_kernels() const { return this->in_kernels_; } @@ -154,19 +154,19 @@ class LiteKernel { void set_desc(const KernelKey kernel_key) { desc_ = kernel_key; } - const mindspore::lite::PrimitiveC *GetPrimitive() const { return primitive_; } - void SetWorkspaceSize(size_t value) { workspace_size_ = value; } - size_t GetWorkspaceSize() { return workspace_size_; } + const mindspore::lite::PrimitiveC *primitive() const { return primitive_; } + void set_workspace_size(size_t value) { workspace_size_ = value; } + size_t workspace_size() { return workspace_size_; } static void AllocWorkspace(size_t size); static void FreeWorkspace(); - void *GetWorkspace() { return workspace_; } + void *workspace() { return workspace_; } SubGraphType subgraph_type() const { return this->subgraph_type_; } virtual std::string ToString() const; protected: - bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->GetInferFlag()); } + bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->infer_flag()); } KernelKey desc_{}; std::string name_; diff --git a/mindspore/lite/src/lite_session.cc b/mindspore/lite/src/lite_session.cc index e3f098329a..d63d953090 100644 --- a/mindspore/lite/src/lite_session.cc +++ b/mindspore/lite/src/lite_session.cc @@ -74,7 +74,7 @@ void LiteSession::ConvertTensorsQuantParam(const schema::Tensor *src_tensor, lit for (size_t j = 0; j < quant_clusters->size(); j++) { clusters.push_back(quant_clusters->Get(j)); } - dst_tensor->SetQuantClusters(clusters); + dst_tensor->set_quant_clusters(clusters); } } diff --git a/mindspore/lite/src/model_common.cc b/mindspore/lite/src/model_common.cc index 83780149ef..13d5ac49bc 100644 --- a/mindspore/lite/src/model_common.cc +++ b/mindspore/lite/src/model_common.cc @@ -43,7 +43,7 @@ bool ConvertNodes(const schema::MetaGraph *meta_graph, Model *model) { delete node; return false; } - node->primitive_->SetQuantType(c_node->quantType()); + node->primitive_->set_quant_type(c_node->quantType()); MS_ASSERT(c_node->name() != nullptr); node->name_ = c_node->name()->c_str(); node->node_type_ = c_node->nodeType(); diff --git a/mindspore/lite/src/ops/adam.cc b/mindspore/lite/src/ops/adam.cc index 33b09ae829..4270efe45a 100644 --- a/mindspore/lite/src/ops/adam.cc +++ b/mindspore/lite/src/ops/adam.cc @@ -88,7 +88,7 @@ int Adam::InferShape(std::vector inputs, std::vectorset_data_type(inputs[0]->data_type()); - out->SetFormat(inputs[0]->GetFormat()); + out->set_format(inputs[0]->format()); out->set_shape({1}); } diff --git a/mindspore/lite/src/ops/addn.cc b/mindspore/lite/src/ops/addn.cc index 711adb99b5..d71e24bdcb 100644 --- a/mindspore/lite/src/ops/addn.cc +++ b/mindspore/lite/src/ops/addn.cc @@ -83,9 +83,9 @@ int AddN::InferShape(std::vector inputs, std::vector outputs MS_LOG(ERROR) << "input size" << inputs.size() << " is error!"; return RET_INPUT_TENSOR_ERROR; } - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); diff --git a/mindspore/lite/src/ops/apply_momentum.cc b/mindspore/lite/src/ops/apply_momentum.cc index b2759bc1e5..4771314f2d 100644 --- a/mindspore/lite/src/ops/apply_momentum.cc +++ b/mindspore/lite/src/ops/apply_momentum.cc @@ -93,7 +93,7 @@ int ApplyMomentum::InferShape(std::vector inputs, std::vector
  • set_data_type(inputs[0]->data_type()); - out->SetFormat(inputs[0]->GetFormat()); + out->set_format(inputs[0]->format()); out->set_shape({1}); } diff --git a/mindspore/lite/src/ops/argmax.cc b/mindspore/lite/src/ops/argmax.cc index b7276de94d..cca4b0e11b 100644 --- a/mindspore/lite/src/ops/argmax.cc +++ b/mindspore/lite/src/ops/argmax.cc @@ -71,9 +71,9 @@ int ArgMax::InferShape(std::vector inputs_, std::vector outp return RET_ERROR; } - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } std::vector output_shape(input->shape()); diff --git a/mindspore/lite/src/ops/argmin.cc b/mindspore/lite/src/ops/argmin.cc index ac6602594e..656a517065 100644 --- a/mindspore/lite/src/ops/argmin.cc +++ b/mindspore/lite/src/ops/argmin.cc @@ -69,9 +69,9 @@ int ArgMin::InferShape(std::vector inputs_, std::vectorSetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto input_shape_size = input->shape().size(); diff --git a/mindspore/lite/src/ops/arithmetic.cc b/mindspore/lite/src/ops/arithmetic.cc index 67218884ac..755417716d 100644 --- a/mindspore/lite/src/ops/arithmetic.cc +++ b/mindspore/lite/src/ops/arithmetic.cc @@ -41,10 +41,10 @@ int Arithmetic::InferShape(std::vector inputs_, std::vectorshape(); auto input_shape1 = input1->shape(); - auto format = input0->GetFormat(); - output->SetFormat(format); + auto format = input0->format(); + output->set_format(format); output->set_data_type(input0->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } if (input_shape0.size() > 10 || input_shape1.size() > 10) { @@ -69,7 +69,7 @@ int Arithmetic::InferShape(std::vector inputs_, std::vectorGetFormat(); + format = input0->format(); } else if (input_shape0.size() > input_shape1.size()) { ndim_ = input_shape0.size(); auto fill_dim_num = input_shape0.size() - input_shape1.size(); diff --git a/mindspore/lite/src/ops/arithmetic_self.cc b/mindspore/lite/src/ops/arithmetic_self.cc index d99304f57c..77187d269e 100644 --- a/mindspore/lite/src/ops/arithmetic_self.cc +++ b/mindspore/lite/src/ops/arithmetic_self.cc @@ -30,9 +30,9 @@ int ArithmeticSelf::InferShape(std::vector inputs_, std::vectorSetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); diff --git a/mindspore/lite/src/ops/assign.cc b/mindspore/lite/src/ops/assign.cc index bda4ca3a62..8a9c2ff405 100644 --- a/mindspore/lite/src/ops/assign.cc +++ b/mindspore/lite/src/ops/assign.cc @@ -80,7 +80,7 @@ int Assign::InferShape(std::vector inputs, std::vectorset_data_type(inputs[0]->data_type()); - out->SetFormat(inputs[0]->GetFormat()); + out->set_format(inputs[0]->format()); out->set_shape({1}); } return RET_OK; diff --git a/mindspore/lite/src/ops/assign_add.cc b/mindspore/lite/src/ops/assign_add.cc index b65f6d23e4..488e221901 100644 --- a/mindspore/lite/src/ops/assign_add.cc +++ b/mindspore/lite/src/ops/assign_add.cc @@ -86,7 +86,7 @@ int AssignAdd::InferShape(std::vector inputs_, std::vector o output_shape[i] = x_shape[i]; } out->set_shape(output_shape); - out->SetFormat(x->GetFormat()); + out->set_format(x->format()); out->set_data_type(x->data_type()); return RET_OK; } diff --git a/mindspore/lite/src/ops/audio_spectrogram.cc b/mindspore/lite/src/ops/audio_spectrogram.cc index ca442c6761..d3a19224b0 100644 --- a/mindspore/lite/src/ops/audio_spectrogram.cc +++ b/mindspore/lite/src/ops/audio_spectrogram.cc @@ -75,8 +75,8 @@ int AudioSpectrogram::InferShape(std::vector inputs_, std::vectorset_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/batch_to_space.cc b/mindspore/lite/src/ops/batch_to_space.cc index 2e34124e22..6156517f0c 100644 --- a/mindspore/lite/src/ops/batch_to_space.cc +++ b/mindspore/lite/src/ops/batch_to_space.cc @@ -91,13 +91,13 @@ int BatchToSpace::InferShape(std::vector inputs, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (input->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "batch_to_space only support NHWC now!"; return RET_FORMAT_ERR; } - outputs[0]->SetFormat(input->GetFormat()); + outputs[0]->set_format(input->format()); outputs[0]->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/bias_grad.cc b/mindspore/lite/src/ops/bias_grad.cc index dfe57ec218..8f93a86826 100644 --- a/mindspore/lite/src/ops/bias_grad.cc +++ b/mindspore/lite/src/ops/bias_grad.cc @@ -106,7 +106,7 @@ int BiasGrad::InferShape(std::vector inputs, std::vector out } out->set_shape(inshape); out->set_data_type(in0->data_type()); - out->SetFormat(in0->GetFormat()); + out->set_format(in0->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/binary_cross_entropy.cc b/mindspore/lite/src/ops/binary_cross_entropy.cc index 174cf062ea..adb344c102 100644 --- a/mindspore/lite/src/ops/binary_cross_entropy.cc +++ b/mindspore/lite/src/ops/binary_cross_entropy.cc @@ -102,7 +102,7 @@ Registry BinaryCrossEntropyRegistry(schema::PrimitiveType_BinaryCrossEntropy, Bi int BinaryCrossEntropy::InferShape(std::vector inputs_, std::vector outputs_) { Tensor *x = inputs_[0]; Tensor *out = outputs_[0]; - out->SetFormat(x->GetFormat()); + out->set_format(x->format()); out->set_data_type(x->data_type()); int reduction = GetReduction(); if (reduction == 1 || reduction == 2) { diff --git a/mindspore/lite/src/ops/binary_cross_entropy_grad.cc b/mindspore/lite/src/ops/binary_cross_entropy_grad.cc index 0248e09716..61016b1075 100644 --- a/mindspore/lite/src/ops/binary_cross_entropy_grad.cc +++ b/mindspore/lite/src/ops/binary_cross_entropy_grad.cc @@ -109,7 +109,7 @@ Registry BinaryCrossEntropyGradRegistry(schema::PrimitiveType_BinaryCrossEntropy int BinaryCrossEntropyGrad::InferShape(std::vector inputs_, std::vector outputs_) { Tensor *x = inputs_[0]; Tensor *out = outputs_[0]; - out->SetFormat(x->GetFormat()); + out->set_format(x->format()); out->set_data_type(x->data_type()); std::vector x_shape = x->shape(); std::vector output_shape(x_shape.size()); diff --git a/mindspore/lite/src/ops/bn_grad.cc b/mindspore/lite/src/ops/bn_grad.cc index 5770a3a9e9..163b9414d5 100644 --- a/mindspore/lite/src/ops/bn_grad.cc +++ b/mindspore/lite/src/ops/bn_grad.cc @@ -96,9 +96,9 @@ int BNGrad::InferShape(std::vector inputs, std::vectorset_data_type(in->data_type()); outputs[1]->set_data_type(scale->data_type()); outputs[2]->set_data_type(scale->data_type()); - outputs[0]->SetFormat(in->GetFormat()); - outputs[1]->SetFormat(scale->GetFormat()); - outputs[2]->SetFormat(scale->GetFormat()); + outputs[0]->set_format(in->format()); + outputs[1]->set_format(scale->format()); + outputs[2]->set_format(scale->format()); return RET_OK; } } // namespace lite diff --git a/mindspore/lite/src/ops/broadcast_to.cc b/mindspore/lite/src/ops/broadcast_to.cc index 49edd976f4..252691712e 100644 --- a/mindspore/lite/src/ops/broadcast_to.cc +++ b/mindspore/lite/src/ops/broadcast_to.cc @@ -77,9 +77,9 @@ int BroadcastTo::InferShape(std::vector inputs, std::vector } auto input = inputs.at(0); - outputs[0]->SetFormat(input->GetFormat()); + outputs[0]->set_format(input->format()); outputs[0]->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } std::vector dst_shape(GetDstShape()); diff --git a/mindspore/lite/src/ops/cast.cc b/mindspore/lite/src/ops/cast.cc index 367a7a6212..1c7ecbab68 100644 --- a/mindspore/lite/src/ops/cast.cc +++ b/mindspore/lite/src/ops/cast.cc @@ -93,11 +93,11 @@ int Cast::InferShape(std::vector inputs_, std::vector output MS_LOG(ERROR) << "tensor number is error."; return RET_INPUT_TENSOR_ERROR; } - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); MS_ASSERT(cast_prim != nullptr); output->set_data_type(static_cast(GetDstT())); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/concat.cc b/mindspore/lite/src/ops/concat.cc index 64e5fe8c32..f5d96d916d 100644 --- a/mindspore/lite/src/ops/concat.cc +++ b/mindspore/lite/src/ops/concat.cc @@ -99,8 +99,8 @@ int Concat::InferShape(std::vector inputs_, std::vector outp return RET_PARAM_INVALID; } output->set_data_type(input0->data_type()); - output->SetFormat(input0->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input0->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/constant_of_shape.cc b/mindspore/lite/src/ops/constant_of_shape.cc index 73630f650d..3626540836 100644 --- a/mindspore/lite/src/ops/constant_of_shape.cc +++ b/mindspore/lite/src/ops/constant_of_shape.cc @@ -81,8 +81,8 @@ int ConstantOfShape::InferShape(std::vector inputs_, std::vectorset_data_type(static_cast(GetDataType())); - out_tensor->SetFormat(in_tensor->GetFormat()); - if (!GetInferFlag()) { + out_tensor->set_format(in_tensor->format()); + if (!infer_flag()) { return RET_OK; } auto in_data = reinterpret_cast(in_tensor->data_c()); diff --git a/mindspore/lite/src/ops/conv2d.cc b/mindspore/lite/src/ops/conv2d.cc index 7cd97f7a52..4c9d79d905 100644 --- a/mindspore/lite/src/ops/conv2d.cc +++ b/mindspore/lite/src/ops/conv2d.cc @@ -179,8 +179,8 @@ void Conv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT } attr->channelMultiplier = channel_mutiplier; - MS_ASSERT(inputs.size() == kAnfPopulaterTwo); - auto input_node = inputs[kAnfPopulaterOne]; + MS_ASSERT(inputs.size() == kAnfPopulaterInputNumTwo); + auto input_node = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(input_node != nullptr); if (input_node->isa()) { auto param_node = input_node->cast(); @@ -192,7 +192,7 @@ void Conv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT MS_ASSERT(abstractTensor != nullptr); if (utils::isa(abstractTensor->BuildShape())) { auto dims = utils::cast(abstractTensor->BuildShape())->shape(); - attr->channelIn = dims[kAnfPopulaterOne]; + attr->channelIn = dims[kAnfPopulaterInputNumOne]; } } } @@ -372,14 +372,14 @@ int Conv2D::InferShape(std::vector inputs_, std::vector outp MS_ASSERT(input_tensor != nullptr); MS_ASSERT(out_tensor != nullptr); - out_tensor->SetFormat(input_tensor->GetFormat()); + out_tensor->set_format(input_tensor->format()); out_tensor->set_data_type(input_tensor->data_type()); pad_l_ = GetPadLeft(); pad_u_ = GetPadUp(); pad_d_ = GetPadDown(); pad_r_ = GetPadRight(); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto in_shape = input_tensor->shape(); diff --git a/mindspore/lite/src/ops/conv2d_grad_filter.cc b/mindspore/lite/src/ops/conv2d_grad_filter.cc index a184eeeef2..1a05e2a13c 100644 --- a/mindspore/lite/src/ops/conv2d_grad_filter.cc +++ b/mindspore/lite/src/ops/conv2d_grad_filter.cc @@ -202,10 +202,10 @@ int Conv2DGradFilter::InferShape(std::vector inputs, std::vector output_shape; int *out_shape = reinterpret_cast(in->MutableData()); int new_size = in->ElementsNum(); - if (in0->GetFormat() == in->GetFormat()) { + if (in0->format() == in->format()) { for (int i = 0; i < new_size; i++) output_shape.push_back(out_shape[i]); } else { - if ((in0->GetFormat() == schema::Format_NHWC) && (in->GetFormat() == schema::Format_NCHW)) { + if ((in0->format() == schema::Format_NHWC) && (in->format() == schema::Format_NCHW)) { output_shape.push_back(out_shape[0]); output_shape.push_back(out_shape[2]); output_shape.push_back(out_shape[3]); @@ -221,7 +221,7 @@ int Conv2DGradFilter::InferShape(std::vector inputs, std::vectorset_shape(output_shape); out->set_data_type(in0->data_type()); - out->SetFormat(in0->GetFormat()); + out->set_format(in0->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/conv2d_grad_input.cc b/mindspore/lite/src/ops/conv2d_grad_input.cc index 4d074f9d8d..e51a847429 100644 --- a/mindspore/lite/src/ops/conv2d_grad_input.cc +++ b/mindspore/lite/src/ops/conv2d_grad_input.cc @@ -205,10 +205,10 @@ int Conv2DGradInput::InferShape(std::vector inputs, std::vector output_shape; int *out_shape = reinterpret_cast(in->MutableData()); int new_size = in->ElementsNum(); - if (in0->GetFormat() == in->GetFormat()) { + if (in0->format() == in->format()) { for (int i = 0; i < new_size; i++) output_shape.push_back(out_shape[i]); } else { - if ((in0->GetFormat() == schema::Format_NHWC) && (in->GetFormat() == schema::Format_NCHW)) { + if ((in0->format() == schema::Format_NHWC) && (in->format() == schema::Format_NCHW)) { output_shape.push_back(out_shape[0]); output_shape.push_back(out_shape[2]); output_shape.push_back(out_shape[3]); @@ -223,7 +223,7 @@ int Conv2DGradInput::InferShape(std::vector inputs, std::vectorset_shape(output_shape); out->set_data_type(in0->data_type()); - out->SetFormat(in0->GetFormat()); + out->set_format(in0->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/crop.cc b/mindspore/lite/src/ops/crop.cc index 141d55f239..15dbd2c00e 100644 --- a/mindspore/lite/src/ops/crop.cc +++ b/mindspore/lite/src/ops/crop.cc @@ -68,9 +68,9 @@ int Crop::InferShape(std::vector inputs, std::vector outputs MS_LOG(ERROR) << "Invalid output/input size! output size: " << outputs.size() << ",input size: " << inputs.size(); return RET_PARAM_INVALID; } - outputs[0]->SetFormat(inputs[0]->GetFormat()); + outputs[0]->set_format(inputs[0]->format()); outputs[0]->set_data_type(inputs[0]->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } outputs[0]->set_shape(inputs[1]->shape()); diff --git a/mindspore/lite/src/ops/custom_extract_features.cc b/mindspore/lite/src/ops/custom_extract_features.cc index 82441a1d4e..5054b25fba 100644 --- a/mindspore/lite/src/ops/custom_extract_features.cc +++ b/mindspore/lite/src/ops/custom_extract_features.cc @@ -50,9 +50,9 @@ int CustomExtractFeatures::InferShape(std::vector inputs_, std::vector MS_ASSERT(output1 != nullptr); output0->set_data_type(kNumberTypeInt32); - output0->SetFormat(input->GetFormat()); + output0->set_format(input->format()); output1->set_data_type(kNumberTypeFloat32); - output1->SetFormat(input->GetFormat()); + output1->set_format(input->format()); if (input->data_c() == nullptr) { MS_LOG(INFO) << "Do infer shape in runtime."; diff --git a/mindspore/lite/src/ops/custom_normalize.cc b/mindspore/lite/src/ops/custom_normalize.cc index e9a9f8f3c8..6ba50c6a59 100644 --- a/mindspore/lite/src/ops/custom_normalize.cc +++ b/mindspore/lite/src/ops/custom_normalize.cc @@ -48,7 +48,7 @@ int CustomNormalize::InferShape(std::vector inputs_, std::vectorset_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); if (input->data_c() == nullptr) { MS_LOG(INFO) << "Do infer shape in runtime."; diff --git a/mindspore/lite/src/ops/custom_predict.cc b/mindspore/lite/src/ops/custom_predict.cc index 8504125059..0afbbfa77d 100644 --- a/mindspore/lite/src/ops/custom_predict.cc +++ b/mindspore/lite/src/ops/custom_predict.cc @@ -69,10 +69,10 @@ int CustomPredict::InferShape(std::vector inputs_, std::vectorset_shape(shape); output0->set_data_type(kNumberTypeInt32); - output0->SetFormat(input->GetFormat()); + output0->set_format(input->format()); output1->set_shape(shape); output1->set_data_type(kNumberTypeFloat32); - output1->SetFormat(input->GetFormat()); + output1->set_format(input->format()); return RET_OK; } } // namespace lite diff --git a/mindspore/lite/src/ops/deconv2d.cc b/mindspore/lite/src/ops/deconv2d.cc index 641372f93a..0ded595e48 100644 --- a/mindspore/lite/src/ops/deconv2d.cc +++ b/mindspore/lite/src/ops/deconv2d.cc @@ -172,8 +172,8 @@ void DeConv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::Primitiv } attr->channelMultiplier = channel_mutiplier; - MS_ASSERT(inputs.size() == kAnfPopulaterTwo); - auto input_node = inputs[kAnfPopulaterOne]; + MS_ASSERT(inputs.size() == kAnfPopulaterInputNumTwo); + auto input_node = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(input_node != nullptr); if (input_node->isa()) { auto param_node = input_node->cast(); @@ -306,9 +306,9 @@ int DeConv2D::InferShape(std::vector inputs_, std::vectorSetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } int32_t input_h = input->Height(); diff --git a/mindspore/lite/src/ops/dedepthwise_conv2d.cc b/mindspore/lite/src/ops/dedepthwise_conv2d.cc index 0d87449547..577b7263ac 100644 --- a/mindspore/lite/src/ops/dedepthwise_conv2d.cc +++ b/mindspore/lite/src/ops/dedepthwise_conv2d.cc @@ -135,9 +135,9 @@ int DeDepthwiseConv2D::InferShape(std::vector inputs_, std::vect MS_ASSERT(weight != nullptr); auto output = outputs_.front(); MS_ASSERT(output != nullptr); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto in_shape = input->shape(); diff --git a/mindspore/lite/src/ops/depth_to_space.cc b/mindspore/lite/src/ops/depth_to_space.cc index 9d35b2ea5f..2ad62eb0fd 100644 --- a/mindspore/lite/src/ops/depth_to_space.cc +++ b/mindspore/lite/src/ops/depth_to_space.cc @@ -66,13 +66,13 @@ int DepthToSpace::InferShape(std::vector inputs, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (input->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "depth_to_space only support NHWC now!"; return RET_FORMAT_ERR; } outputs[0]->set_data_type(input->data_type()); - outputs[0]->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + outputs[0]->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/depthwise_conv2d.cc b/mindspore/lite/src/ops/depthwise_conv2d.cc index f54bd3141f..f50fe20e1a 100644 --- a/mindspore/lite/src/ops/depthwise_conv2d.cc +++ b/mindspore/lite/src/ops/depthwise_conv2d.cc @@ -127,8 +127,8 @@ int DepthwiseConv2D::UnPackAttr(const Primitive &prim, const std::vector(prim.GetAttr("channel_multiplier")); attr->channelMultiplier = channel_multiplier; - MS_ASSERT(inputs.size() == kAnfPopulaterTwo); - auto inputNode = inputs[kAnfPopulaterOne]; + MS_ASSERT(inputs.size() == kAnfPopulaterInputNumTwo); + auto inputNode = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(inputNode != nullptr); if (inputNode->isa()) { auto paramNode = inputNode->cast(); @@ -139,7 +139,7 @@ int DepthwiseConv2D::UnPackAttr(const Primitive &prim, const std::vector(abstractTensor->BuildShape())) { auto dims = utils::cast(abstractTensor->BuildShape())->shape(); - attr->channelIn = dims[kAnfPopulaterOne]; + attr->channelIn = dims[kAnfPopulaterInputNumOne]; } } } @@ -211,14 +211,14 @@ int DepthwiseConv2D::InferShape(std::vector inputs_, std::vector MS_ASSERT(weight != nullptr); auto output = outputs_.front(); MS_ASSERT(output != nullptr); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); pad_l_ = GetPadLeft(); pad_u_ = GetPadUp(); pad_d_ = GetPadDown(); pad_r_ = GetPadRight(); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto in_shape = input->shape(); diff --git a/mindspore/lite/src/ops/detection_post_process.cc b/mindspore/lite/src/ops/detection_post_process.cc index 1a179ea57d..9e24966d40 100644 --- a/mindspore/lite/src/ops/detection_post_process.cc +++ b/mindspore/lite/src/ops/detection_post_process.cc @@ -181,15 +181,15 @@ int DetectionPostProcess::InferShape(std::vector inputs_, std::v auto num_det = outputs_.at(3); MS_ASSERT(num_det != nullptr); - detected_boxes->SetFormat(boxes->GetFormat()); + detected_boxes->set_format(boxes->format()); detected_boxes->set_data_type(kNumberTypeFloat32); - detected_classes->SetFormat(boxes->GetFormat()); + detected_classes->set_format(boxes->format()); detected_classes->set_data_type(kNumberTypeFloat32); - detected_scores->SetFormat(boxes->GetFormat()); + detected_scores->set_format(boxes->format()); detected_scores->set_data_type(kNumberTypeFloat32); - num_det->SetFormat(boxes->GetFormat()); + num_det->set_format(boxes->format()); num_det->set_data_type(kNumberTypeFloat32); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } const auto max_detections = GetMaxDetections(); diff --git a/mindspore/lite/src/ops/embedding_lookup.cc b/mindspore/lite/src/ops/embedding_lookup.cc index 97958a89b3..0ef4ba49e1 100644 --- a/mindspore/lite/src/ops/embedding_lookup.cc +++ b/mindspore/lite/src/ops/embedding_lookup.cc @@ -67,9 +67,9 @@ int EmbeddingLookup::InferShape(std::vector inputs_, std::vectorSetFormat(params_->GetFormat()); + output->set_format(params_->format()); output->set_data_type(params_->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/equal.cc b/mindspore/lite/src/ops/equal.cc index 2b4e3aa62d..dd55c8f265 100644 --- a/mindspore/lite/src/ops/equal.cc +++ b/mindspore/lite/src/ops/equal.cc @@ -42,7 +42,7 @@ int Equal::InferShape(std::vector inputs_, std::vector outpu MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/expand_dims.cc b/mindspore/lite/src/ops/expand_dims.cc index ee8bc767cc..bad20631c3 100644 --- a/mindspore/lite/src/ops/expand_dims.cc +++ b/mindspore/lite/src/ops/expand_dims.cc @@ -101,8 +101,8 @@ int ExpandDims::InferShape(std::vector inputs_, std::vector MS_LOG(ERROR) << "output size is invalid"; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } int dim = GetDim(); diff --git a/mindspore/lite/src/ops/fft_imag.cc b/mindspore/lite/src/ops/fft_imag.cc index 3e2f6c07f9..86bde09c86 100644 --- a/mindspore/lite/src/ops/fft_imag.cc +++ b/mindspore/lite/src/ops/fft_imag.cc @@ -41,8 +41,8 @@ int FftImag::InferShape(std::vector inputs_, std::vector out auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(TypeId::kNumberTypeFloat32); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/fft_real.cc b/mindspore/lite/src/ops/fft_real.cc index de68c73723..fcf7dd5a43 100644 --- a/mindspore/lite/src/ops/fft_real.cc +++ b/mindspore/lite/src/ops/fft_real.cc @@ -41,8 +41,8 @@ int FftReal::InferShape(std::vector inputs_, std::vector out auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(TypeId::kNumberTypeFloat32); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/fill.cc b/mindspore/lite/src/ops/fill.cc index 40196fa909..4c08e4b20a 100644 --- a/mindspore/lite/src/ops/fill.cc +++ b/mindspore/lite/src/ops/fill.cc @@ -69,8 +69,8 @@ int Fill::InferShape(std::vector inputs_, std::vector output return RET_INPUT_TENSOR_ERROR; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/flatten.cc b/mindspore/lite/src/ops/flatten.cc index c37a5d7ed5..6555b26607 100644 --- a/mindspore/lite/src/ops/flatten.cc +++ b/mindspore/lite/src/ops/flatten.cc @@ -38,8 +38,8 @@ int Flatten::InferShape(std::vector inputs_, std::vector out } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/flatten_grad.cc b/mindspore/lite/src/ops/flatten_grad.cc index 44bced4370..5796ce5702 100644 --- a/mindspore/lite/src/ops/flatten_grad.cc +++ b/mindspore/lite/src/ops/flatten_grad.cc @@ -37,8 +37,8 @@ int FlattenGrad::InferShape(std::vector inputs_, std::vector } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/full_connection.cc b/mindspore/lite/src/ops/full_connection.cc index 5958742493..a6e26dc86d 100644 --- a/mindspore/lite/src/ops/full_connection.cc +++ b/mindspore/lite/src/ops/full_connection.cc @@ -69,7 +69,7 @@ int FullConnection::InferShape(std::vector inputs_, std::vector< MS_ASSERT(input1 != nullptr); auto output = outputs_.front(); MS_ASSERT(output != nullptr); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } if ((GetHasBias() && inputs_.size() != kMultiNum) || (!GetHasBias() && inputs_.size() != kDoubleNum)) { @@ -114,7 +114,7 @@ int FullConnection::InferShape(std::vector inputs_, std::vector< } output->set_shape(out_shape); output->set_data_type(input0->data_type()); - output->SetFormat(input0->GetFormat()); + output->set_format(input0->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/fused_batchnorm.cc b/mindspore/lite/src/ops/fused_batchnorm.cc index 5e9a899002..aaad730cb6 100644 --- a/mindspore/lite/src/ops/fused_batchnorm.cc +++ b/mindspore/lite/src/ops/fused_batchnorm.cc @@ -91,11 +91,11 @@ int FusedBatchNorm::InferShape(std::vector inputs_, std::vector< if (outputs_.size() <= i) break; outputs_.at(i)->set_shape(inputs_.at(i)->shape()); outputs_.at(i)->set_data_type(inputs_.at(i)->data_type()); - outputs_.at(i)->SetFormat(inputs_.at(i)->GetFormat()); + outputs_.at(i)->set_format(inputs_.at(i)->format()); } if (outputs_.size() > 5) { outputs_.at(5)->set_data_type(inputs_.at(0)->data_type()); - outputs_.at(5)->SetFormat(inputs_.at(0)->GetFormat()); + outputs_.at(5)->set_format(inputs_.at(0)->format()); outputs_.at(5)->set_shape({1}); } return 0; diff --git a/mindspore/lite/src/ops/gather.cc b/mindspore/lite/src/ops/gather.cc index 4881c1b117..2e8eb4d972 100644 --- a/mindspore/lite/src/ops/gather.cc +++ b/mindspore/lite/src/ops/gather.cc @@ -112,8 +112,8 @@ int Gather::InferShape(std::vector inputs_, std::vector outp auto output = outputs_.front(); MS_ASSERT(input != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/gather_nd.cc b/mindspore/lite/src/ops/gather_nd.cc index b0d7e4c621..ce266aa68a 100644 --- a/mindspore/lite/src/ops/gather_nd.cc +++ b/mindspore/lite/src/ops/gather_nd.cc @@ -68,8 +68,8 @@ int GatherNd::InferShape(std::vector inputs_, std::vector ou MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto in_shape = input->shape(); diff --git a/mindspore/lite/src/ops/greater.cc b/mindspore/lite/src/ops/greater.cc index b30da60029..f6df714250 100644 --- a/mindspore/lite/src/ops/greater.cc +++ b/mindspore/lite/src/ops/greater.cc @@ -43,7 +43,7 @@ int Greater::InferShape(std::vector inputs_, std::vector out MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/greater_equal.cc b/mindspore/lite/src/ops/greater_equal.cc index cf83423f55..7cbf55237d 100644 --- a/mindspore/lite/src/ops/greater_equal.cc +++ b/mindspore/lite/src/ops/greater_equal.cc @@ -45,7 +45,7 @@ int GreaterEqual::InferShape(std::vector inputs_, std::vectorset_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/group_conv2d_grad_input.cc b/mindspore/lite/src/ops/group_conv2d_grad_input.cc index dfcfd7466c..e3dfb4d8a5 100644 --- a/mindspore/lite/src/ops/group_conv2d_grad_input.cc +++ b/mindspore/lite/src/ops/group_conv2d_grad_input.cc @@ -154,10 +154,10 @@ int GroupConv2DGradInput::InferShape(std::vector inputs, std::vector output_shape; int *out_shape = reinterpret_cast(in->MutableData()); int new_size = in->ElementsNum(); - if (in0->GetFormat() == in->GetFormat()) { + if (in0->format() == in->format()) { for (int i = 0; i < new_size; i++) output_shape.push_back(out_shape[i]); } else { - if ((in0->GetFormat() == schema::Format_NHWC) && (in->GetFormat() == schema::Format_NCHW)) { + if ((in0->format() == schema::Format_NHWC) && (in->format() == schema::Format_NCHW)) { output_shape.push_back(out_shape[0]); output_shape.push_back(out_shape[2]); output_shape.push_back(out_shape[3]); @@ -172,7 +172,7 @@ int GroupConv2DGradInput::InferShape(std::vector inputs, std::vectorset_shape(output_shape); out->set_data_type(in0->data_type()); - out->SetFormat(in0->GetFormat()); + out->set_format(in0->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/hashtable_lookup.cc b/mindspore/lite/src/ops/hashtable_lookup.cc index cba417ad12..34ad2df0cd 100644 --- a/mindspore/lite/src/ops/hashtable_lookup.cc +++ b/mindspore/lite/src/ops/hashtable_lookup.cc @@ -55,10 +55,10 @@ int HashtableLookup::InferShape(std::vector inputs_, std::vectorDimensionSize(0)); output->set_data_type(values->data_type()); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); hits->set_shape(hits_shape); hits->set_data_type(kNumberTypeUInt8); - hits->SetFormat(input->GetFormat()); + hits->set_format(input->format()); if (input->data_c() == nullptr) { MS_LOG(INFO) << "Do infer shape in runtime."; diff --git a/mindspore/lite/src/ops/layer_norm.cc b/mindspore/lite/src/ops/layer_norm.cc index 79bf2abbd6..c26018764f 100644 --- a/mindspore/lite/src/ops/layer_norm.cc +++ b/mindspore/lite/src/ops/layer_norm.cc @@ -78,7 +78,7 @@ int LayerNorm::InferShape(std::vector inputs_, std::vectorSetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); if (GetElementwiseAffine() && inputs_.size() != kMultiNum) { @@ -102,7 +102,7 @@ int LayerNorm::InferShape(std::vector inputs_, std::vector inputs_, std::vector output MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/less_equal.cc b/mindspore/lite/src/ops/less_equal.cc index 22163f5aef..7ecadad839 100644 --- a/mindspore/lite/src/ops/less_equal.cc +++ b/mindspore/lite/src/ops/less_equal.cc @@ -44,7 +44,7 @@ int LessEqual::InferShape(std::vector inputs_, std::vector o MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/lsh_projection.cc b/mindspore/lite/src/ops/lsh_projection.cc index 2883d66e18..8387422fe4 100644 --- a/mindspore/lite/src/ops/lsh_projection.cc +++ b/mindspore/lite/src/ops/lsh_projection.cc @@ -70,7 +70,7 @@ int LshProjection::InferShape(std::vector inputs_, std::vectorset_data_type(kNumberTypeInt32); - out_tensor->SetFormat(schema::Format::Format_NHWC); + out_tensor->set_format(schema::Format::Format_NHWC); std::vector out_shape; switch (GetLshType()) { diff --git a/mindspore/lite/src/ops/lstm.cc b/mindspore/lite/src/ops/lstm.cc index f22f69afef..59074352f4 100644 --- a/mindspore/lite/src/ops/lstm.cc +++ b/mindspore/lite/src/ops/lstm.cc @@ -65,9 +65,9 @@ int Lstm::InferShape(std::vector inputs_, std::vector output MS_ASSERT(output != nullptr); for (int i = 0; i < kLstmOutputNum; i++) { outputs_[i]->set_data_type(input->data_type()); - outputs_[i]->SetFormat(input->GetFormat()); + outputs_[i]->set_format(input->format()); } - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/matmul.cc b/mindspore/lite/src/ops/matmul.cc index e07fa9b70b..2ea7a7b6cc 100644 --- a/mindspore/lite/src/ops/matmul.cc +++ b/mindspore/lite/src/ops/matmul.cc @@ -99,8 +99,8 @@ int MatMul::InferShape(std::vector inputs_, std::vector outp MS_ASSERT(output != nullptr); output->set_data_type(input0->data_type()); - output->SetFormat(input0->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input0->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/mean.cc b/mindspore/lite/src/ops/mean.cc index d4a9c838d8..e6be5f2fae 100644 --- a/mindspore/lite/src/ops/mean.cc +++ b/mindspore/lite/src/ops/mean.cc @@ -75,8 +75,8 @@ int Mean::InferShape(std::vector inputs_, std::vector output return RET_NULL_PTR; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } if (this->primitive_ == nullptr) { diff --git a/mindspore/lite/src/ops/mfcc.cc b/mindspore/lite/src/ops/mfcc.cc index f184e33b50..c7e5d023f0 100644 --- a/mindspore/lite/src/ops/mfcc.cc +++ b/mindspore/lite/src/ops/mfcc.cc @@ -57,8 +57,8 @@ int Mfcc::InferShape(std::vector inputs_, std::vector output auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/nchw2nhwc.cc b/mindspore/lite/src/ops/nchw2nhwc.cc index ac60eadfcb..b73db62e82 100644 --- a/mindspore/lite/src/ops/nchw2nhwc.cc +++ b/mindspore/lite/src/ops/nchw2nhwc.cc @@ -45,9 +45,9 @@ int Nchw2Nhwc::InferShape(std::vector inputs_, std::vectorSetFormat(schema::Format::Format_NHWC); + output->set_format(schema::Format::Format_NHWC); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } std::vector nchw_shape = input->shape(); diff --git a/mindspore/lite/src/ops/nhwc2nchw.cc b/mindspore/lite/src/ops/nhwc2nchw.cc index 97fa7db85e..dfe27f5269 100644 --- a/mindspore/lite/src/ops/nhwc2nchw.cc +++ b/mindspore/lite/src/ops/nhwc2nchw.cc @@ -46,9 +46,9 @@ int Nhwc2Nchw::InferShape(std::vector inputs_, std::vectorSetFormat(schema::Format::Format_NCHW); + output->set_format(schema::Format::Format_NCHW); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } std::vector nhwc_shape = input->shape(); diff --git a/mindspore/lite/src/ops/non_max_suppression.cc b/mindspore/lite/src/ops/non_max_suppression.cc index 2f933cd859..131a8594c1 100644 --- a/mindspore/lite/src/ops/non_max_suppression.cc +++ b/mindspore/lite/src/ops/non_max_suppression.cc @@ -62,7 +62,7 @@ int NonMaxSuppression::InferShape(std::vector inputs_, std::vectorset_data_type(kNumberTypeInt32); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); MS_LOG(INFO) << "NonMaxSuppression infer shape in runtime."; return RET_INFER_INVALID; } diff --git a/mindspore/lite/src/ops/not_equal.cc b/mindspore/lite/src/ops/not_equal.cc index b8128ede6e..2a7b5fb0fe 100644 --- a/mindspore/lite/src/ops/not_equal.cc +++ b/mindspore/lite/src/ops/not_equal.cc @@ -45,7 +45,7 @@ int NotEqual::InferShape(std::vector inputs_, std::vector ou MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(TypeId::kNumberTypeBool); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } diff --git a/mindspore/lite/src/ops/one_hot.cc b/mindspore/lite/src/ops/one_hot.cc index 93f1857bcd..2349cbf3a6 100644 --- a/mindspore/lite/src/ops/one_hot.cc +++ b/mindspore/lite/src/ops/one_hot.cc @@ -112,8 +112,8 @@ int OneHot::InferShape(std::vector inputs, std::vector outpu return RET_NULL_PTR; } output->set_data_type(on_value->data_type()); - output->SetFormat(on_value->GetFormat()); - if (!GetInferFlag()) { + output->set_format(on_value->format()); + if (!infer_flag()) { return RET_OK; } const auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/oneslike.cc b/mindspore/lite/src/ops/oneslike.cc index d447de56b9..5ddd86ee01 100644 --- a/mindspore/lite/src/ops/oneslike.cc +++ b/mindspore/lite/src/ops/oneslike.cc @@ -78,7 +78,7 @@ int OnesLike::InferShape(std::vector inputs_, std::vector ou std::vector output_shape(x_shape.size()); output_shape.assign(x_shape.begin(), x_shape.end()); out->set_shape(output_shape); - out->SetFormat(x->GetFormat()); + out->set_format(x->format()); out->set_data_type(x->data_type()); return RET_OK; } diff --git a/mindspore/lite/src/ops/pad.cc b/mindspore/lite/src/ops/pad.cc index 86d01f18a9..4d96c9195a 100644 --- a/mindspore/lite/src/ops/pad.cc +++ b/mindspore/lite/src/ops/pad.cc @@ -80,9 +80,9 @@ int Pad::InferShape(std::vector inputs, std::vector outputs) if (output == nullptr) { return RET_NULL_PTR; } - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/pooling.cc b/mindspore/lite/src/ops/pooling.cc index 3b415339c6..52eb7c61cf 100644 --- a/mindspore/lite/src/ops/pooling.cc +++ b/mindspore/lite/src/ops/pooling.cc @@ -179,8 +179,8 @@ int Pooling::InferShape(std::vector inputs_, std::vector out auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(schema::Format::Format_NHWC); - if (!GetInferFlag()) { + output->set_format(schema::Format::Format_NHWC); + if (!infer_flag()) { return RET_OK; } int input_h = input->shape().at(1); diff --git a/mindspore/lite/src/ops/pooling_grad.cc b/mindspore/lite/src/ops/pooling_grad.cc index 9d2e633d2b..9a24dcf66b 100644 --- a/mindspore/lite/src/ops/pooling_grad.cc +++ b/mindspore/lite/src/ops/pooling_grad.cc @@ -203,7 +203,7 @@ int PoolingGrad::InferShape(std::vector inputs_, std::vector grad_output->set_shape(output_shape); grad_output->set_data_type(input->data_type()); // todo: temp fix - grad_output->SetFormat(input->GetFormat()); + grad_output->set_format(input->format()); return RET_OK; } } // namespace lite diff --git a/mindspore/lite/src/ops/power.cc b/mindspore/lite/src/ops/power.cc index f99bfa8124..1a8c1a4acb 100644 --- a/mindspore/lite/src/ops/power.cc +++ b/mindspore/lite/src/ops/power.cc @@ -113,8 +113,8 @@ int Power::InferShape(std::vector inputs, std::vector output auto output_tensor = outputs[0]; MS_ASSERT(output_tensor != nullptr); output_tensor->set_data_type(x_tensor->data_type()); - output_tensor->SetFormat(x_tensor->GetFormat()); - if (!GetInferFlag()) { + output_tensor->set_format(x_tensor->format()); + if (!infer_flag()) { return RET_OK; } if (exp_tensor != nullptr) { diff --git a/mindspore/lite/src/ops/primitive_c.cc b/mindspore/lite/src/ops/primitive_c.cc index ab56dbae83..ca954b6d23 100644 --- a/mindspore/lite/src/ops/primitive_c.cc +++ b/mindspore/lite/src/ops/primitive_c.cc @@ -310,24 +310,25 @@ void PrimitiveC::GetAttrDataFromInput(const AnfNodePtr inputNode, std::vectorprimitive_; } +schema::PrimitiveT *PrimitiveC::primitiveT() const { return this->primitive_; } void PrimitiveC::ClearPrimitiveT() { this->primitive_ = nullptr; } -void PrimitiveC::SetInputQuantParams(const std::vector> &input_quant_param) { +void PrimitiveC::set_input_quant_params(const std::vector> &input_quant_param) { this->input_quant_param_ = input_quant_param; } -void PrimitiveC::SetInputQuantParam(const size_t &index, const std::vector &input_quant_param) { +void PrimitiveC::set_input_quant_param(const size_t &index, const std::vector &input_quant_param) { MS_ASSERT(index < this->input_quant_param_.size()); this->input_quant_param_[index] = input_quant_param; } -void PrimitiveC::SetOutputQuantParams(const std::vector> &output_quant_param) { +void PrimitiveC::set_output_quant_params(const std::vector> &output_quant_param) { this->output_quant_param_ = output_quant_param; } -void PrimitiveC::SetOutputQuantParam(const size_t &index, const std::vector &output_quant_param) { +void PrimitiveC::set_output_quant_param(const size_t &index, + const std::vector &output_quant_param) { MS_ASSERT(index < this->output_quant_param_.size()); this->output_quant_param_[index] = output_quant_param; } @@ -364,16 +365,16 @@ void PrimitiveC::ClearInputOutputQuantParam() { void PrimitiveC::AddInputQuantParam(std::vector quant_param) { this->input_quant_param_.emplace_back(quant_param); } -std::vector> PrimitiveC::GetInputQuantParams() const { return input_quant_param_; } +std::vector> PrimitiveC::input_quant_params() const { return input_quant_param_; } void PrimitiveC::AddOutputQuantParam(std::vector quant_param) { this->output_quant_param_.emplace_back(quant_param); } -std::vector> PrimitiveC::GetOutputQuantParams() const { return output_quant_param_; } +std::vector> PrimitiveC::output_quant_params() const { return output_quant_param_; } -void PrimitiveC::SetQuantType(const schema::QuantType &quant_type) { this->quant_type_ = quant_type; } +void PrimitiveC::set_quant_type(const schema::QuantType &quant_type) { this->quant_type_ = quant_type; } -schema::QuantType PrimitiveC::GetQuantType() const { return quant_type_; } +schema::QuantType PrimitiveC::quant_type() const { return quant_type_; } std::shared_ptr GetReturnPrim() { auto return_primitiveT = new (std::nothrow) schema::PrimitiveT; @@ -431,7 +432,7 @@ std::shared_ptr NewPrimitiveC(const Primitive &prim, const std::vect MS_LOG(ERROR) << "make_shared PrimitiveC failed"; return nullptr; } - primc->SetQuantType(quantType); + primc->set_quant_type(quantType); auto ret = primc->UnPackAttr(prim, inputs); if (ret != RET_OK) { MS_LOG(ERROR) << "UnPackAttr failed"; @@ -906,8 +907,8 @@ PrimitiveC *PrimitiveC::Create(mindspore::schema::PrimitiveT *primitive) { return nullptr; } #else -void PrimitiveC::SetQuantType(schema::QuantType quant_type) { this->quant_type_ = quant_type; } -schema::QuantType PrimitiveC::GetQuantType() const { return quant_type_; } +void PrimitiveC::set_quant_type(schema::QuantType quant_type) { this->quant_type_ = quant_type; } +schema::QuantType PrimitiveC::quant_type() const { return quant_type_; } #endif int PrimitiveC::Type() const { @@ -920,18 +921,18 @@ int PrimitiveC::Type() const { return this->primitive_->value_type(); #endif } -bool PrimitiveC::GetInferFlag() const { return this->infer_flag_; } +bool PrimitiveC::infer_flag() const { return this->infer_flag_; } -void PrimitiveC::SetInferFlag(bool flag) { this->infer_flag_ = flag; } +void PrimitiveC::set_infer_flag(bool flag) { this->infer_flag_ = flag; } -int PrimitiveC::InferShape(std::vector inputs_, std::vector outputs_) { - auto input = inputs_.front(); +int PrimitiveC::InferShape(std::vector inputs, std::vector outputs) { + auto input = inputs.front(); MS_ASSERT(input != nullptr); - auto output = outputs_.front(); + auto output = outputs.front(); MS_ASSERT(output != nullptr); output->set_shape(input->shape()); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return 0; } diff --git a/mindspore/lite/src/ops/primitive_c.h b/mindspore/lite/src/ops/primitive_c.h index 9dc0519958..5a00e66528 100644 --- a/mindspore/lite/src/ops/primitive_c.h +++ b/mindspore/lite/src/ops/primitive_c.h @@ -44,9 +44,9 @@ const std::set kSupportDataType = {kNumberTypeBool, kNumberTypeUInt8, kN #ifdef PRIMITIVE_WRITEABLE using TensorPtr = std::shared_ptr; -constexpr int kAnfPopulaterOne = 1; -constexpr int kAnfPopulaterTwo = 2; -constexpr int kAnfPopulaterThree = 3; +constexpr int kAnfPopulaterInputNumOne = 1; +constexpr int kAnfPopulaterInputNumTwo = 2; +constexpr int kAnfPopulaterInputNumThree = 3; static std::map kActivationTypeMap{{"ReLU", schema::ActivationType_RELU}, {"ReLU6", schema::ActivationType_RELU6}, {"Sigmoid", schema::ActivationType_SIGMOID}, @@ -73,7 +73,7 @@ class PrimitiveC : public mindspore::Primitive { int Type() const; - schema::PrimitiveT *GetPrimitiveT() const; + schema::PrimitiveT *primitiveT() const; void ClearPrimitiveT(); @@ -88,13 +88,13 @@ class PrimitiveC : public mindspore::Primitive { } } - void SetInputQuantParams(const std::vector> &input_quant_param); + void set_input_quant_params(const std::vector> &input_quant_param); - void SetInputQuantParam(const size_t &index, const std::vector &input_quant_param); + void set_input_quant_param(const size_t &index, const std::vector &input_quant_param); - void SetOutputQuantParams(const std::vector> &output_quant_param); + void set_output_quant_params(const std::vector> &output_quant_param); - void SetOutputQuantParam(const size_t &index, const std::vector &output_quant_param); + void set_output_quant_param(const size_t &index, const std::vector &output_quant_param); bool IsInputQuantParamsInited(); @@ -104,21 +104,21 @@ class PrimitiveC : public mindspore::Primitive { void AddInputQuantParam(std::vector quant_param); - std::vector> GetInputQuantParams() const; + std::vector> input_quant_params() const; void AddOutputQuantParam(std::vector quant_param); - std::vector> GetOutputQuantParams() const; + std::vector> output_quant_params() const; - void SetQuantType(const schema::QuantType &quant_type); + void set_quant_type(const schema::QuantType &quant_type); - schema::QuantType GetQuantType() const; + schema::QuantType quant_type() const; - virtual int InferShape(std::vector inputs_, std::vector outputs_); + virtual int InferShape(std::vector inputs, std::vector outputs); - bool GetInferFlag() const; + bool infer_flag() const; - void SetInferFlag(bool flag); + void set_infer_flag(bool flag); static PrimitiveC *Create(mindspore::schema::Primitive *primitive) { return Create(primitive->UnPack()); } @@ -160,16 +160,16 @@ class PrimitiveC { static PrimitiveC *Create(const schema::Primitive *primitive); - bool GetInferFlag() const; + bool infer_flag() const; - void SetInferFlag(bool flag); + void set_infer_flag(bool flag); virtual int InferShape(std::vector inputs, std::vector outputs); int Type() const; - void SetQuantType(schema::QuantType quant_type); - schema::QuantType GetQuantType() const; + void set_quant_type(schema::QuantType quant_type); + schema::QuantType quant_type() const; template ::value>> static PrimitiveC *NewPrimitiveC(const schema::Primitive *primitive) { diff --git a/mindspore/lite/src/ops/prior_box.cc b/mindspore/lite/src/ops/prior_box.cc index f32a5c3aed..024c8eda91 100644 --- a/mindspore/lite/src/ops/prior_box.cc +++ b/mindspore/lite/src/ops/prior_box.cc @@ -138,8 +138,8 @@ int PriorBox::InferShape(std::vector inputs_, std::vector ou auto output = outputs_.at(0); MS_ASSERT(output != nullptr); output->set_data_type(kNumberTypeFloat32); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } std::vector different_aspect_ratios{1.0f}; diff --git a/mindspore/lite/src/ops/quant_dtype_cast.cc b/mindspore/lite/src/ops/quant_dtype_cast.cc index e42d5f46b3..42564b9293 100644 --- a/mindspore/lite/src/ops/quant_dtype_cast.cc +++ b/mindspore/lite/src/ops/quant_dtype_cast.cc @@ -61,8 +61,8 @@ int QuantDTypeCast::InferShape(std::vector inputs_, std::vectordata_type() == param->srcT); output->set_data_type(static_cast(GetDstT())); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); diff --git a/mindspore/lite/src/ops/range.cc b/mindspore/lite/src/ops/range.cc index df4f1b8ae1..479f95a7f0 100644 --- a/mindspore/lite/src/ops/range.cc +++ b/mindspore/lite/src/ops/range.cc @@ -67,8 +67,8 @@ int Range::InferShape(std::vector inputs_, std::vector outpu MS_ASSERT(range_prim != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/rank.cc b/mindspore/lite/src/ops/rank.cc index a3130bb5a5..1ef39d11c9 100644 --- a/mindspore/lite/src/ops/rank.cc +++ b/mindspore/lite/src/ops/rank.cc @@ -43,8 +43,8 @@ int Rank::InferShape(std::vector inputs_, std::vector output auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } std::vector in_shape(1, 1); diff --git a/mindspore/lite/src/ops/reduce.cc b/mindspore/lite/src/ops/reduce.cc index 03c5eea50b..c5270efb0a 100644 --- a/mindspore/lite/src/ops/reduce.cc +++ b/mindspore/lite/src/ops/reduce.cc @@ -70,8 +70,8 @@ int Reduce::UnPackAttr(const Primitive &prim, const std::vector &inp } attr->keepDims = GetValue(prim.GetAttr("keep_dims")); - if (inputs.size() == kAnfPopulaterTwo) { - auto inputNode = inputs[kAnfPopulaterOne]; + if (inputs.size() == kAnfPopulaterInputNumTwo) { + auto inputNode = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(inputNode != nullptr); if (inputNode->isa()) { auto valueNode = inputNode->cast(); @@ -150,8 +150,8 @@ int Reduce::InferShape(std::vector inputs_, std::vector outp return RET_NULL_PTR; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } if (this->primitive_ == nullptr) { diff --git a/mindspore/lite/src/ops/reshape.cc b/mindspore/lite/src/ops/reshape.cc index c9171eb731..ab082ac0a2 100644 --- a/mindspore/lite/src/ops/reshape.cc +++ b/mindspore/lite/src/ops/reshape.cc @@ -47,8 +47,8 @@ int Reshape::UnPackAttr(const Primitive &prim, const std::vector &in } if (this->primitive_->value.value == nullptr) { auto attr = new (std::nothrow) schema::ReshapeT(); - MS_ASSERT(inputs.size() == kAnfPopulaterThree - 1); - auto inputNode = inputs[kAnfPopulaterTwo - 1]; + MS_ASSERT(inputs.size() == kAnfPopulaterInputNumThree - 1); + auto inputNode = inputs[kAnfPopulaterInputNumTwo - 1]; if (inputNode->isa()) { auto valueNode = inputNode->cast(); MS_ASSERT(valueNode != nullptr); @@ -171,8 +171,8 @@ int Reshape::InferShape(std::vector inputs_, std::vector out auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/resize.cc b/mindspore/lite/src/ops/resize.cc index a2638be972..2d38939feb 100644 --- a/mindspore/lite/src/ops/resize.cc +++ b/mindspore/lite/src/ops/resize.cc @@ -129,8 +129,8 @@ int Resize::InferShape(std::vector inputs_, std::vectorset_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } @@ -151,7 +151,7 @@ int Resize::InferShape(std::vector inputs_, std::vectorGetFormat()) { + switch (shape_tensor->format()) { case schema::Format_NCHW: output_shape.push_back(data[2] * input->Height()); output_shape.push_back(data[3] * input->Width()); @@ -170,7 +170,7 @@ int Resize::InferShape(std::vector inputs_, std::vectorGetFormat()) { + switch (shape_tensor->format()) { case schema::Format_NCHW: output_shape.push_back(data[2] * input->Height()); output_shape.push_back(data[3] * input->Width()); diff --git a/mindspore/lite/src/ops/return.cc b/mindspore/lite/src/ops/return.cc index 4486992e49..d7120104b3 100644 --- a/mindspore/lite/src/ops/return.cc +++ b/mindspore/lite/src/ops/return.cc @@ -70,8 +70,8 @@ int Return::InferShape(std::vector inputs_, std::vector outp return RET_NULL_PTR; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } if (this->primitive_ == nullptr) { @@ -79,7 +79,7 @@ int Return::InferShape(std::vector inputs_, std::vector outp } output->set_data_type(input->data_type()); output->set_shape(input->shape()); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } } // namespace lite diff --git a/mindspore/lite/src/ops/reverse_sequence.cc b/mindspore/lite/src/ops/reverse_sequence.cc index e7c84f4ee7..42b908b875 100644 --- a/mindspore/lite/src/ops/reverse_sequence.cc +++ b/mindspore/lite/src/ops/reverse_sequence.cc @@ -64,8 +64,8 @@ int ReverseSequence::InferShape(std::vector inputs, std::vectorset_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); diff --git a/mindspore/lite/src/ops/rfft.cc b/mindspore/lite/src/ops/rfft.cc index e83d3210bf..09378f2470 100644 --- a/mindspore/lite/src/ops/rfft.cc +++ b/mindspore/lite/src/ops/rfft.cc @@ -52,8 +52,8 @@ int Rfft::InferShape(std::vector inputs_, std::vector output auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(TypeId::kNumberTypeComplex64); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/roi_pooling.cc b/mindspore/lite/src/ops/roi_pooling.cc index d6efa6f235..260da92804 100644 --- a/mindspore/lite/src/ops/roi_pooling.cc +++ b/mindspore/lite/src/ops/roi_pooling.cc @@ -77,8 +77,8 @@ int ROIPooling::InferShape(std::vector inputs_, std::vector return RET_NULL_PTR; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/scatter_nd.cc b/mindspore/lite/src/ops/scatter_nd.cc index 1115e1169e..c89162fb2d 100644 --- a/mindspore/lite/src/ops/scatter_nd.cc +++ b/mindspore/lite/src/ops/scatter_nd.cc @@ -56,8 +56,8 @@ int ScatterND::InferShape(std::vector inputs_, std::vector o } auto output = outputs_.front(); output->set_data_type(update->data_type()); - output->SetFormat(update->GetFormat()); - if (!GetInferFlag()) { + output->set_format(update->format()); + if (!infer_flag()) { return RET_OK; } auto shape_data = reinterpret_cast(shape->MutableData()); diff --git a/mindspore/lite/src/ops/sgd.cc b/mindspore/lite/src/ops/sgd.cc index 8a357deee6..65636c03a7 100644 --- a/mindspore/lite/src/ops/sgd.cc +++ b/mindspore/lite/src/ops/sgd.cc @@ -95,7 +95,7 @@ int Sgd::InferShape(std::vector inputs, std::vectorset_data_type(inputs[0]->data_type()); - out->SetFormat(inputs[0]->GetFormat()); + out->set_format(inputs[0]->format()); out->set_shape({1}); } diff --git a/mindspore/lite/src/ops/shape.cc b/mindspore/lite/src/ops/shape.cc index 9199467b72..ebd976b98c 100644 --- a/mindspore/lite/src/ops/shape.cc +++ b/mindspore/lite/src/ops/shape.cc @@ -42,8 +42,8 @@ int Shape::InferShape(std::vector inputs_, std::vector outpu auto in_tensor = inputs_.front(); auto out_tensor = outputs_.front(); out_tensor->set_data_type(kNumberTypeInt32); - out_tensor->SetFormat(schema::Format::Format_NHWC); - if (!GetInferFlag()) { + out_tensor->set_format(schema::Format::Format_NHWC); + if (!infer_flag()) { return RET_OK; } std::vector out_shape; diff --git a/mindspore/lite/src/ops/skip_gram.cc b/mindspore/lite/src/ops/skip_gram.cc index 7ccdcf9240..253cce09a7 100644 --- a/mindspore/lite/src/ops/skip_gram.cc +++ b/mindspore/lite/src/ops/skip_gram.cc @@ -73,7 +73,7 @@ int SkipGram::InferShape(std::vector inputs_, std::vector ou auto input = inputs_.front(); auto output = outputs_.front(); MS_ASSERT(input != nullptr); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); output->set_data_type(input->data_type()); if (input->data_c() == nullptr) { diff --git a/mindspore/lite/src/ops/slice.cc b/mindspore/lite/src/ops/slice.cc index c36fcce858..9fd84b09b2 100644 --- a/mindspore/lite/src/ops/slice.cc +++ b/mindspore/lite/src/ops/slice.cc @@ -59,8 +59,8 @@ int Slice::UnPackAttr(const Primitive &prim, const std::vector &inpu MS_LOG(ERROR) << "new primitiveT value failed"; return RET_ERROR; } - if (inputs.size() >= kAnfPopulaterThree) { - auto beginNode = inputs[kAnfPopulaterOne]; + if (inputs.size() >= kAnfPopulaterInputNumThree) { + auto beginNode = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(beginNode != nullptr); if (beginNode->isa()) { auto valueNode = beginNode->cast(); @@ -77,7 +77,7 @@ int Slice::UnPackAttr(const Primitive &prim, const std::vector &inpu } } } - auto sizeNode = inputs[kAnfPopulaterTwo]; + auto sizeNode = inputs[kAnfPopulaterInputNumTwo]; MS_ASSERT(sizeNode != nullptr); if (sizeNode->isa()) { auto valueNode = sizeNode->cast(); @@ -173,8 +173,8 @@ int Slice::InferShape(std::vector inputs, std::vectorset_data_type(input->data_type()); - outputs[0]->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + outputs[0]->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/softmax.cc b/mindspore/lite/src/ops/softmax.cc index 099c6ee3ac..2151aecba1 100644 --- a/mindspore/lite/src/ops/softmax.cc +++ b/mindspore/lite/src/ops/softmax.cc @@ -84,8 +84,8 @@ int SoftMax::InferShape(std::vector inputs_, std::vector out auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } if (input->shape().size() > 5) { diff --git a/mindspore/lite/src/ops/softmax_cross_entropy.cc b/mindspore/lite/src/ops/softmax_cross_entropy.cc index f2a4caaab0..66af7ba552 100644 --- a/mindspore/lite/src/ops/softmax_cross_entropy.cc +++ b/mindspore/lite/src/ops/softmax_cross_entropy.cc @@ -103,14 +103,14 @@ int SoftmaxCrossEntropy::InferShape(std::vector inputs, std::vectorset_shape(outshape); out->set_data_type(in0->data_type()); - out->SetFormat(in0->GetFormat()); + out->set_format(in0->format()); if (1 < outputs.size()) { auto *grads = outputs.at(1); MS_ASSERT(grads != nullptr); grads->set_shape(in0->shape()); grads->set_data_type(in0->data_type()); - grads->SetFormat(in0->GetFormat()); + grads->set_format(in0->format()); } return RET_OK; } diff --git a/mindspore/lite/src/ops/space_to_batch.cc b/mindspore/lite/src/ops/space_to_batch.cc index 4e4d00e4fd..650a864f37 100644 --- a/mindspore/lite/src/ops/space_to_batch.cc +++ b/mindspore/lite/src/ops/space_to_batch.cc @@ -92,13 +92,13 @@ int SpaceToBatch::InferShape(std::vector inputs, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (input->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "space_to_batch only support NHWC now!"; return 1; } outputs[0]->set_data_type(input->data_type()); - outputs[0]->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + outputs[0]->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/space_to_batch_nd.cc b/mindspore/lite/src/ops/space_to_batch_nd.cc index 640b6e50a9..a820c4bdd4 100644 --- a/mindspore/lite/src/ops/space_to_batch_nd.cc +++ b/mindspore/lite/src/ops/space_to_batch_nd.cc @@ -94,13 +94,13 @@ int SpaceToBatchND::InferShape(std::vector inputs, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (input->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "space_to_batch_nd only support NHWC now!"; return RET_ERROR; } outputs[0]->set_data_type(input->data_type()); - outputs[0]->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + outputs[0]->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/space_to_depth.cc b/mindspore/lite/src/ops/space_to_depth.cc index 6bb61fc84c..b98be02b2e 100644 --- a/mindspore/lite/src/ops/space_to_depth.cc +++ b/mindspore/lite/src/ops/space_to_depth.cc @@ -67,13 +67,13 @@ int SpaceToDepth::InferShape(std::vector inputs, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (input->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "space_to_depth only support NHWC now!"; return 1; } - outputs[0]->SetFormat(input->GetFormat()); + outputs[0]->set_format(input->format()); outputs[0]->set_data_type(input->data_type()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/sparse_to_dense.cc b/mindspore/lite/src/ops/sparse_to_dense.cc index 9192f2823a..5171b574c8 100644 --- a/mindspore/lite/src/ops/sparse_to_dense.cc +++ b/mindspore/lite/src/ops/sparse_to_dense.cc @@ -62,9 +62,9 @@ int SparseToDense::InferShape(std::vector inputs_, std::vectorset_data_type(input2->data_type()); - outputs_[0]->SetFormat(input2->GetFormat()); + outputs_[0]->set_format(input2->format()); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } if (this->primitive_ == nullptr) { diff --git a/mindspore/lite/src/ops/split.cc b/mindspore/lite/src/ops/split.cc index 7f62a3a8a8..babfcde454 100644 --- a/mindspore/lite/src/ops/split.cc +++ b/mindspore/lite/src/ops/split.cc @@ -121,9 +121,9 @@ int Split::InferShape(std::vector inputs_, std::vector outpu } for (int i = 0; i < number_split; ++i) { outputs_[i]->set_data_type(input->data_type()); - outputs_[i]->SetFormat(input->GetFormat()); + outputs_[i]->set_format(input->format()); } - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } size_t split_dim = GetSplitDim() == -1 ? input->shape().size() - 1 : GetSplitDim(); @@ -149,7 +149,7 @@ int Split::InferShape(std::vector inputs_, std::vector outpu output_shape[split_dim] = split_dim_i; outputs_[i]->set_shape(output_shape); outputs_[i]->set_data_type(input->data_type()); - outputs_[i]->SetFormat(input->GetFormat()); + outputs_[i]->set_format(input->format()); } return RET_OK; } diff --git a/mindspore/lite/src/ops/squeeze.cc b/mindspore/lite/src/ops/squeeze.cc index 700bee9494..33ccefa23b 100644 --- a/mindspore/lite/src/ops/squeeze.cc +++ b/mindspore/lite/src/ops/squeeze.cc @@ -104,8 +104,8 @@ int Squeeze::InferShape(std::vector inputs_, std::vector out } auto *in_tensor = inputs_.front(); outputs_.front()->set_data_type(in_tensor->data_type()); - outputs_.front()->SetFormat(in_tensor->GetFormat()); - if (!GetInferFlag()) { + outputs_.front()->set_format(in_tensor->format()); + if (!infer_flag()) { return RET_OK; } auto in_shape = in_tensor->shape(); diff --git a/mindspore/lite/src/ops/stack.cc b/mindspore/lite/src/ops/stack.cc index dd1daa7688..f6bee87c56 100644 --- a/mindspore/lite/src/ops/stack.cc +++ b/mindspore/lite/src/ops/stack.cc @@ -81,8 +81,8 @@ int Stack::InferShape(std::vector inputs, std::vector output auto input = inputs.at(0); auto input0_data_type = input->data_type(); outputs[0]->set_data_type(input0_data_type); - outputs[0]->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + outputs[0]->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } auto input_shape = input->shape(); diff --git a/mindspore/lite/src/ops/strided_slice.cc b/mindspore/lite/src/ops/strided_slice.cc index 8b6a8fa97d..dd2fcfd5ee 100644 --- a/mindspore/lite/src/ops/strided_slice.cc +++ b/mindspore/lite/src/ops/strided_slice.cc @@ -77,17 +77,17 @@ int StridedSlice::UnPackAttr(const Primitive &prim, const std::vectorellipsisMask = GetValue(prim.GetAttr("ellipsis_mask")); attr->newAxisMask = GetValue(prim.GetAttr("new_axis_mask")); attr->shrinkAxisMask = GetValue(prim.GetAttr("shrink_axis_mask")); - auto inputNodeFirst = inputs[kAnfPopulaterOne]; + auto inputNodeFirst = inputs[kAnfPopulaterInputNumOne]; std::vector beginVec; GetAttrDataFromInput(inputNodeFirst, &beginVec); attr->begin = beginVec; - auto inputNodeSecond = inputs[kAnfPopulaterTwo]; + auto inputNodeSecond = inputs[kAnfPopulaterInputNumTwo]; std::vector endVec; GetAttrDataFromInput(inputNodeSecond, &endVec); attr->end = endVec; - auto inputNodeThird = inputs[kAnfPopulaterThree]; + auto inputNodeThird = inputs[kAnfPopulaterInputNumThree]; std::vector strideVec; GetAttrDataFromInput(inputNodeThird, &strideVec); attr->stride = strideVec; @@ -263,10 +263,10 @@ int StridedSlice::InferShape(std::vector inputs, std::vectorset_data_type(input->data_type()); - outputs[0]->SetFormat(input->GetFormat()); + outputs[0]->set_format(input->format()); MS_ASSERT(input != nullptr); auto input_shape = input->shape(); - auto inferflag = GetInferFlag(); + auto inferflag = infer_flag(); if (inputs.size() == kStridedSliceInputNum) { ndim_ = static_cast(GetBegin().size()); diff --git a/mindspore/lite/src/ops/tile.cc b/mindspore/lite/src/ops/tile.cc index d4f8c53da1..21bacac1e6 100644 --- a/mindspore/lite/src/ops/tile.cc +++ b/mindspore/lite/src/ops/tile.cc @@ -58,8 +58,8 @@ int Tile::UnPackAttr(const Primitive &prim, const std::vector &input } else { attr->dims = GetValue>(prim.GetAttr("dims")); } - if (inputs.size() == kAnfPopulaterTwo) { - auto inputNode = inputs[kAnfPopulaterOne]; + if (inputs.size() == kAnfPopulaterInputNumTwo) { + auto inputNode = inputs[kAnfPopulaterInputNumOne]; MS_ASSERT(inputNode != nullptr); if (inputNode->isa()) { auto valueNode = inputNode->cast(); @@ -133,8 +133,8 @@ int Tile::InferShape(std::vector inputs_, std::vector output auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/topk.cc b/mindspore/lite/src/ops/topk.cc index ad27295547..9850b70231 100644 --- a/mindspore/lite/src/ops/topk.cc +++ b/mindspore/lite/src/ops/topk.cc @@ -65,10 +65,10 @@ int TopK::InferShape(std::vector inputs_, std::vector output auto output1 = outputs_.at(1); MS_ASSERT(output1 != nullptr); output0->set_data_type(input->data_type()); - output0->SetFormat(input->GetFormat()); + output0->set_format(input->format()); output1->set_data_type(kNumberTypeInt32); - output1->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output1->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } MS_ASSERT(topk_prim != nullptr); diff --git a/mindspore/lite/src/ops/transpose.cc b/mindspore/lite/src/ops/transpose.cc index a228dda6f3..4ba637f4fb 100644 --- a/mindspore/lite/src/ops/transpose.cc +++ b/mindspore/lite/src/ops/transpose.cc @@ -51,8 +51,8 @@ int Transpose::UnPackAttr(const Primitive &prim, const std::vector & MS_LOG(ERROR) << "new TransposeT failed"; return RET_ERROR; } - MS_ASSERT(inputs.size() == kAnfPopulaterTwo); - auto inputNode = inputs[kAnfPopulaterOne]; + MS_ASSERT(inputs.size() == kAnfPopulaterInputNumTwo); + auto inputNode = inputs[kAnfPopulaterInputNumOne]; if (inputNode->isa()) { auto valNode = inputNode->cast(); MS_ASSERT(valNode != nullptr); @@ -120,8 +120,8 @@ int Transpose::InferShape(std::vector inputs_, std::vector o auto output = outputs_.front(); MS_ASSERT(output != nullptr); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } MS_ASSERT(inputs_.size() == kSingleNum); diff --git a/mindspore/lite/src/ops/unique.cc b/mindspore/lite/src/ops/unique.cc index 45c01553f6..69dff48528 100644 --- a/mindspore/lite/src/ops/unique.cc +++ b/mindspore/lite/src/ops/unique.cc @@ -62,9 +62,9 @@ int Unique::InferShape(std::vector inputs_, std::vector outp MS_ASSERT(output1 != nullptr); output0->set_data_type(input->data_type()); output1->set_data_type(kNumberTypeInt32); - output1->SetFormat(input->GetFormat()); - output0->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output1->set_format(input->format()); + output0->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } output0->set_shape(input->shape()); diff --git a/mindspore/lite/src/ops/unsorted_segment_sum.cc b/mindspore/lite/src/ops/unsorted_segment_sum.cc index 3356128d5d..1b70031cad 100644 --- a/mindspore/lite/src/ops/unsorted_segment_sum.cc +++ b/mindspore/lite/src/ops/unsorted_segment_sum.cc @@ -102,7 +102,7 @@ int UnsortedSegmentSum::InferShape(std::vector inputs_, std::vectorset_shape(output_shape); - out->SetFormat(x->GetFormat()); + out->set_format(x->format()); out->set_data_type(x->data_type()); return RET_OK; } diff --git a/mindspore/lite/src/ops/unsqueeze.cc b/mindspore/lite/src/ops/unsqueeze.cc index 44629e4d58..930feba040 100644 --- a/mindspore/lite/src/ops/unsqueeze.cc +++ b/mindspore/lite/src/ops/unsqueeze.cc @@ -76,8 +76,8 @@ int Unsqueeze::InferShape(std::vector inputs_, std::vector o MS_LOG(ERROR) << "output size is invalid"; } output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } diff --git a/mindspore/lite/src/ops/unstack.cc b/mindspore/lite/src/ops/unstack.cc index a9f9d929e8..0e2954ecd7 100644 --- a/mindspore/lite/src/ops/unstack.cc +++ b/mindspore/lite/src/ops/unstack.cc @@ -63,9 +63,9 @@ int Unstack::InferShape(std::vector inputs, std::vector outp for (auto &out : outputs) { MS_ASSERT(out != nullptr); out->set_data_type(input->data_type()); - out->SetFormat(input->GetFormat()); + out->set_format(input->format()); } - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } std::vector output_shape; diff --git a/mindspore/lite/src/ops/where.cc b/mindspore/lite/src/ops/where.cc index d108141a96..cc85c95b89 100644 --- a/mindspore/lite/src/ops/where.cc +++ b/mindspore/lite/src/ops/where.cc @@ -79,8 +79,8 @@ int Where::InferShape(std::vector inputs_, std::vector outpu auto input1 = inputs_.at(1); auto input2 = inputs_.at(2); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } int num = input0->ElementsNum(); diff --git a/mindspore/lite/src/ops/while.cc b/mindspore/lite/src/ops/while.cc index ac5e4915a2..1e23040852 100644 --- a/mindspore/lite/src/ops/while.cc +++ b/mindspore/lite/src/ops/while.cc @@ -97,7 +97,7 @@ int While::InferShape(std::vector inputs_, std::vector outpu } for (size_t i = 0; i < inputs_.size(); i++) { outputs_[i]->set_data_type(inputs_[i]->data_type()); - outputs_[i]->SetFormat(inputs_[i]->GetFormat()); + outputs_[i]->set_format(inputs_[i]->format()); outputs_[i]->set_shape(inputs_[i]->shape()); } diff --git a/mindspore/lite/src/ops/zeros_like.cc b/mindspore/lite/src/ops/zeros_like.cc index 2ec562edfe..2fe8b52634 100644 --- a/mindspore/lite/src/ops/zeros_like.cc +++ b/mindspore/lite/src/ops/zeros_like.cc @@ -54,8 +54,8 @@ int ZerosLike::InferShape(std::vector inputs_, std::vectorset_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); - if (!GetInferFlag()) { + output->set_format(input->format()); + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); diff --git a/mindspore/lite/src/runtime/allocator.cc b/mindspore/lite/src/runtime/allocator.cc index 7d0894a3cf..f76dd0aba2 100644 --- a/mindspore/lite/src/runtime/allocator.cc +++ b/mindspore/lite/src/runtime/allocator.cc @@ -28,19 +28,19 @@ DefaultAllocator::DefaultAllocator() {} DefaultAllocator::~DefaultAllocator() { Clear(); } void DefaultAllocator::SetContext(const AllocatorContext &ctx) { - lockFlag = ctx.lockFlag; - shiftFactor = ctx.shiftFactor; + lock_flag_ = ctx.lockFlag; + shift_factor_ = ctx.shiftFactor; } void DefaultAllocator::Lock() { - if (lockFlag) { - lock.lock(); + if (lock_flag_) { + lock_.lock(); } } void DefaultAllocator::UnLock() { - if (lockFlag) { - lock.unlock(); + if (lock_flag_) { + lock_.unlock(); } } @@ -50,11 +50,11 @@ void *DefaultAllocator::Malloc(size_t size) { return nullptr; } Lock(); - auto iter = freeList.lower_bound(size); - if (iter != freeList.end() && (iter->second->size >= size) && (iter->second->size < (size << shiftFactor))) { + auto iter = free_list_.lower_bound(size); + if (iter != free_list_.end() && (iter->second->size >= size) && (iter->second->size < (size << shift_factor_))) { auto membuf = iter->second; - freeList.erase(iter); - allocatedList[membuf->buf] = membuf; + free_list_.erase(iter); + allocated_list_[membuf->buf] = membuf; UnLock(); return membuf->buf; } @@ -68,7 +68,7 @@ void *DefaultAllocator::Malloc(size_t size) { membuf->size = size; membuf->buf = reinterpret_cast(membuf.get()) + sizeof(MemBuf); auto bufPtr = membuf->buf; - allocatedList[bufPtr] = membuf.release(); + allocated_list_[bufPtr] = membuf.release(); UnLock(); return bufPtr; } @@ -78,11 +78,11 @@ void DefaultAllocator::Free(void *buf) { return; } Lock(); - auto iter = allocatedList.find(buf); - if (iter != allocatedList.end()) { + auto iter = allocated_list_.find(buf); + if (iter != allocated_list_.end()) { auto membuf = iter->second; - allocatedList.erase(iter); - freeList.insert(std::make_pair(membuf->size, membuf)); + allocated_list_.erase(iter); + free_list_.insert(std::make_pair(membuf->size, membuf)); UnLock(); return; } @@ -94,12 +94,12 @@ size_t DefaultAllocator::GetTotalSize() { Lock(); size_t totalSize = 0; - for (auto it = allocatedList.begin(); it != allocatedList.end(); it++) { + for (auto it = allocated_list_.begin(); it != allocated_list_.end(); it++) { auto membuf = it->second; totalSize += membuf->size; } - for (auto it = freeList.begin(); it != freeList.end(); it++) { + for (auto it = free_list_.begin(); it != free_list_.end(); it++) { auto membuf = it->second; totalSize += membuf->size; } @@ -110,15 +110,15 @@ size_t DefaultAllocator::GetTotalSize() { void DefaultAllocator::Clear() { Lock(); - for (auto it = allocatedList.begin(); it != allocatedList.end(); it++) { + for (auto it = allocated_list_.begin(); it != allocated_list_.end(); it++) { free(it->second); } - allocatedList.clear(); + allocated_list_.clear(); - for (auto it = freeList.begin(); it != freeList.end(); it++) { + for (auto it = free_list_.begin(); it != free_list_.end(); it++) { free(it->second); } - freeList.clear(); + free_list_.clear(); UnLock(); } } // namespace mindspore::lite diff --git a/mindspore/lite/src/runtime/allocator.h b/mindspore/lite/src/runtime/allocator.h index fe16bfed8c..80520bf5ec 100644 --- a/mindspore/lite/src/runtime/allocator.h +++ b/mindspore/lite/src/runtime/allocator.h @@ -63,13 +63,13 @@ class DefaultAllocator : public Allocator { void *buf; }; - std::mutex lock; + std::mutex lock_; // buf, membuf> - std::unordered_map allocatedList; - std::multimap freeList; + std::unordered_map allocated_list_; + std::multimap free_list_; // 6 is empirical value - int shiftFactor = 6; - bool lockFlag = false; + int shift_factor_ = 6; + bool lock_flag_ = false; }; #define MAX_MALLOC_SIZE (2000 * 1024 * 1024) diff --git a/mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc index 7066af04d8..b1c62ed5a5 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc @@ -30,7 +30,7 @@ using mindspore::schema::PrimitiveType_BatchToSpaceND; namespace mindspore::kernel { int BatchToSpaceBaseCPUKernel::Init() { - if (in_tensors_[0]->GetFormat() != schema::Format::Format_NHWC) { + if (in_tensors_[0]->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "batch_to_space only support NHWC now!"; return RET_FORMAT_ERR; } diff --git a/mindspore/lite/src/runtime/kernel/arm/base/convolution_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/convolution_base.cc index a6fe5c0759..d536544ffc 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/convolution_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/convolution_base.cc @@ -149,9 +149,9 @@ int ConvolutionBaseCPUKernel::MallocQuantParam() { auto input_tensor = in_tensors_.at(kInputIndex); auto weight_tensor = in_tensors_.at(kWeightIndex); auto output_tensor = out_tensors_.at(kOutputIndex); - size_t input_arg_num = input_tensor->GetQuantParams().size(); - size_t filter_arg_num = weight_tensor->GetQuantParams().size(); - size_t output_arg_num = output_tensor->GetQuantParams().size(); + size_t input_arg_num = input_tensor->quant_params().size(); + size_t filter_arg_num = weight_tensor->quant_params().size(); + size_t output_arg_num = output_tensor->quant_params().size(); conv_quant_arg_->input_arg_num_ = input_arg_num; conv_quant_arg_->filter_arg_num_ = filter_arg_num; conv_quant_arg_->output_arg_num_ = output_arg_num; @@ -178,7 +178,7 @@ int ConvolutionBaseCPUKernel::SetInputTensorQuantParam() { auto input_tensor = in_tensors_.at(kInputIndex); auto in_arg_num = conv_quant_arg_->input_arg_num_; if (in_arg_num == kPerTensor) { - auto input_quant_arg = input_tensor->GetQuantParams().front(); + auto input_quant_arg = input_tensor->quant_params().front(); conv_quant_arg_->input_quant_args_[0].zp_ = input_quant_arg.zeroPoint; conv_quant_arg_->input_quant_args_[0].scale_ = input_quant_arg.scale; } else { @@ -193,11 +193,11 @@ int ConvolutionBaseCPUKernel::SetFilterTensorQuantParam() { auto weight_tensor = in_tensors_.at(kWeightIndex); auto weight_arg_num = conv_quant_arg_->filter_arg_num_; if (weight_arg_num == kPerTensor) { - auto weight_quant_arg = weight_tensor->GetQuantParams().front(); + auto weight_quant_arg = weight_tensor->quant_params().front(); conv_quant_arg_->filter_quant_args_[0].zp_ = weight_quant_arg.zeroPoint; conv_quant_arg_->filter_quant_args_[0].scale_ = weight_quant_arg.scale; } else { - auto weight_quant_arg = weight_tensor->GetQuantParams(); + auto weight_quant_arg = weight_tensor->quant_params(); for (size_t i = 0; i < weight_arg_num; ++i) { conv_quant_arg_->filter_quant_args_[i].zp_ = weight_quant_arg[i].zeroPoint; conv_quant_arg_->filter_quant_args_[i].scale_ = weight_quant_arg[i].scale; @@ -210,7 +210,7 @@ int ConvolutionBaseCPUKernel::SetOutputTensorQuantParam() { auto output_tensor = out_tensors_.at(kOutputIndex); auto out_arg_num = conv_quant_arg_->output_arg_num_; if (out_arg_num == kPerTensor) { - auto output_quant_arg = output_tensor->GetQuantParams().front(); + auto output_quant_arg = output_tensor->quant_params().front(); conv_quant_arg_->output_quant_args_[0].zp_ = output_quant_arg.zeroPoint; conv_quant_arg_->output_quant_args_[0].scale_ = output_quant_arg.scale; } else { diff --git a/mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc index 4ffb3a1915..eecdc03411 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc @@ -33,7 +33,7 @@ namespace mindspore::kernel { int DepthToSpaceBaseCPUKernel::Init() { return RET_OK; } int DepthToSpaceBaseCPUKernel::ReSize() { - if (in_tensors_[0]->GetFormat() != schema::Format::Format_NHWC) { + if (in_tensors_[0]->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "depth_to_space only support NHWC now!"; return RET_FORMAT_ERR; } diff --git a/mindspore/lite/src/runtime/kernel/arm/base/dequant.cc b/mindspore/lite/src/runtime/kernel/arm/base/dequant.cc index 32a8c2e776..4fe4d191e4 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/dequant.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/dequant.cc @@ -23,7 +23,7 @@ float *DequantUtil::DequantWeight(lite::Tensor *input_tensor) { MS_LOG(ERROR) << "Conv weight input type error." << input_tensor->data_type(); return nullptr; } - if (input_tensor->GetQuantParams().empty()) { + if (input_tensor->quant_params().empty()) { MS_LOG(ERROR) << "No quant param."; return nullptr; } diff --git a/mindspore/lite/src/runtime/kernel/arm/base/dequant.h b/mindspore/lite/src/runtime/kernel/arm/base/dequant.h index 3193f380dd..ba0ba807d0 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/dequant.h +++ b/mindspore/lite/src/runtime/kernel/arm/base/dequant.h @@ -44,9 +44,9 @@ class DequantUtil { return nullptr; } if (input_tensor->shape().size() == kPerBatch && - input_tensor->GetQuantParams().size() == static_cast(input_tensor->shape()[0])) { // per batch matmul + input_tensor->quant_params().size() == static_cast(input_tensor->shape()[0])) { // per batch matmul auto per_batch_size = input_tensor->shape()[0]; - auto quant_param = input_tensor->GetQuantParams(); + auto quant_param = input_tensor->quant_params(); for (int i = 0; i < per_batch_size; i++) { auto param = quant_param.at(i); auto scale = param.scale; @@ -57,15 +57,15 @@ class DequantUtil { static_cast((quant_datas[i * matrix_size + j] - zero_point) * scale); } } - } else if (input_tensor->GetQuantParams().size() != kPerTensor) { + } else if (input_tensor->quant_params().size() != kPerTensor) { auto channels = static_cast(input_tensor->Batch()); - if (input_tensor->GetQuantParams().size() != channels) { - MS_LOG(ERROR) << "Quant param not equal channel num " << input_tensor->GetQuantParams().size() << channels; + if (input_tensor->quant_params().size() != channels) { + MS_LOG(ERROR) << "Quant param not equal channel num " << input_tensor->quant_params().size() << channels; free(dequant_datas); return nullptr; } size_t per_channel_size = input_tensor->ElementsNum() / channels; - auto quant_param = input_tensor->GetQuantParams(); + auto quant_param = input_tensor->quant_params(); for (size_t i = 0; i < channels; i++) { auto param = quant_param.at(i); auto scale = param.scale; @@ -82,8 +82,8 @@ class DequantUtil { } } } else { - auto quant_param = input_tensor->GetQuantParams(); - auto quant_clusters = input_tensor->GetQuantClusters(); + auto quant_param = input_tensor->quant_params(); + auto quant_clusters = input_tensor->quant_clusters(); auto param = quant_param.front(); auto scale = param.scale; auto zero_point = param.zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/base/detection_post_process_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/detection_post_process_base.cc index 19a58f4b6e..12d2ab6e11 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/detection_post_process_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/detection_post_process_base.cc @@ -48,7 +48,7 @@ int DetectionPostProcessBaseCPUKernel::Init() { params_->anchors_ = nullptr; auto anchor_tensor = in_tensors_.at(2); if (anchor_tensor->data_type() == kNumberTypeInt8) { - auto quant_param = anchor_tensor->GetQuantParams().front(); + auto quant_param = anchor_tensor->quant_params().front(); auto anchor_int8 = reinterpret_cast(anchor_tensor->MutableData()); auto anchor_fp32 = new (std::nothrow) float[anchor_tensor->ElementsNum()]; if (anchor_fp32 == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc index fe4c696187..29094c06d1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/fullconnection_base.cc @@ -43,8 +43,8 @@ kernel::LiteKernel *CpuFullConnectionFp32KernelCreator(const std::vectordata_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc b/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc index a614446aaf..7a1cc29c23 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc @@ -51,9 +51,9 @@ int PoolingBaseCPUKernel::SetQuantParam() { return RET_MEMORY_FAILED; } auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_arg = input_tensor->GetQuantParams(); + auto in_quant_arg = input_tensor->quant_params(); auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_arg = out_tensor->GetQuantParams(); + auto out_quant_arg = out_tensor->quant_params(); pooling_quant_arg_[0][0].scale_ = in_quant_arg.front().scale; pooling_quant_arg_[0][0].zp_ = in_quant_arg.front().zeroPoint; pooling_quant_arg_[1][0].scale_ = out_quant_arg.front().scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc b/mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc index 454c48b207..8ef4881b51 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/quant_dtype_cast.cc @@ -107,13 +107,12 @@ int QuantDTypeCastCPUKernel::QuantDTypeCast(int task_id) { return RET_OK; } int thread_offset = task_id * thread_n_stride_; - if (in_tensors_.front()->GetQuantParams().empty() && out_tensors_.front()->GetQuantParams().empty()) { + if (in_tensors_.front()->quant_params().empty() && out_tensors_.front()->quant_params().empty()) { MS_LOG(ERROR) << "QuantDTypeCast need quantization parameters which is not found."; return RET_ERROR; } - auto quant_arg = out_tensors_.front()->GetQuantParams().front().inited - ? out_tensors_.front()->GetQuantParams().front() - : in_tensors_.front()->GetQuantParams().front(); + auto quant_arg = out_tensors_.front()->quant_params().front().inited ? out_tensors_.front()->quant_params().front() + : in_tensors_.front()->quant_params().front(); int ret = RET_OK; if (src_dtype == TypeId::kNumberTypeInt8 && dst_dtype == TypeId::kNumberTypeFloat32) { ret = DoDequantizeInt8ToFp32(int8_ptr_ + thread_offset, float32_ptr_ + thread_offset, quant_arg.scale, @@ -132,11 +131,11 @@ int QuantDTypeCastCPUKernel::QuantDTypeCast(int task_id) { } else if (src_dtype == TypeId::kNumberTypeUInt8 && dst_dtype == TypeId::kNumberTypeInt8) { ret = UInt8ToInt8(uint8_ptr_ + thread_offset, int8_ptr_ + thread_offset, num_unit_thread); } else if (src_dtype == TypeId::kNumberTypeInt8 && dst_dtype == TypeId::kNumberTypeInt8) { - auto input_quant_arg = in_tensors_.front()->GetQuantParams().front(); + auto input_quant_arg = in_tensors_.front()->quant_params().front(); ret = DoDequantizeInt8ToFp32(int8_ptr_ + thread_offset, float32_ptr_ + thread_offset, num_unit_thread, input_quant_arg.scale, input_quant_arg.zeroPoint); if (ret) { - auto output_quant_arg = out_tensors_.front()->GetQuantParams().front(); + auto output_quant_arg = out_tensors_.front()->quant_params().front(); ret = DoQuantizeFp32ToInt8(float32_ptr_ + thread_offset, int8_out_ptr_ + thread_offset, output_quant_arg.scale, output_quant_arg.zeroPoint, num_unit_thread); } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc index d28facc4b3..f331a16ecc 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc @@ -102,10 +102,10 @@ int ArithmeticFP16CPUKernel::Init() { int ArithmeticFP16CPUKernel::PreProcess() { if (!InferShapeDone()) { - (const_cast(primitive_))->SetInferFlag(true); + (const_cast(primitive_))->set_infer_flag(true); auto ret = (const_cast(primitive_))->InferShape(in_tensors_, out_tensors_); if (ret != 0) { - (const_cast(primitive_))->SetInferFlag(false); + (const_cast(primitive_))->set_infer_flag(false); MS_LOG(ERROR) << "InferShape fail!"; return ret; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc index 15efd883a5..6bed2282eb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc @@ -141,8 +141,8 @@ kernel::LiteKernel *CpuConvDwFp16KernelCreator(const std::vector auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc index 89fd1fc41c..c504e27a06 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc @@ -248,7 +248,7 @@ kernel::LiteKernel *CpuGroupConvFp16KernelCreator(const std::vectorGetInferFlag()); + bool infered_flag = (primitive != nullptr && primitive->infer_flag()); if (infered_flag) { int batch = inputs.front()->Batch(); @@ -364,7 +364,7 @@ kernel::LiteKernel *CpuGroupConvFp16KernelCreator(const std::vectorset_data_type(outputs.at(j)->data_type()); - tmp_out_tensor->SetFormat(outputs.at(j)->GetFormat()); + tmp_out_tensor->set_format(outputs.at(j)->format()); if (infered_flag) { tmp_out_tensor->set_shape(out_shape); ret = tmp_out_tensor->MallocData(); @@ -397,8 +397,8 @@ kernel::LiteKernel *CpuConvFp16KernelCreator(const std::vector & auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { @@ -413,7 +413,7 @@ kernel::LiteKernel *CpuConvFp16KernelCreator(const std::vector & auto conv_param = reinterpret_cast(opParameter); bool use_winograd = false; int out_unit; - if (primitive != nullptr && primitive->GetInferFlag()) { + if (primitive != nullptr && primitive->infer_flag()) { conv_param->input_h_ = inputs.front()->Height(); conv_param->input_w_ = inputs.front()->Width(); conv_param->input_channel_ = inputs.front()->Channel(); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc index 7affecc40d..54bceb7514 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc @@ -215,8 +215,8 @@ kernel::LiteKernel *CpuDeconvDwFp16KernelCreator(const std::vectordata_c(); auto restore_type = weight_tensor->data_type(); - auto dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + auto dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc index c3f4dd361d..e886b3da71 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc @@ -217,8 +217,8 @@ kernel::LiteKernel *CpuDeConvFp16KernelCreator(const std::vector auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - auto dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + auto dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc index e91af0ada3..9b2e731efa 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc @@ -242,8 +242,8 @@ kernel::LiteKernel *CpuFullConnectionFp16KernelCreator(const std::vectordata_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/group_convolution_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/group_convolution_fp16.cc index 0cecba2449..a1ec3a827f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/group_convolution_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/group_convolution_fp16.cc @@ -72,11 +72,11 @@ int GroupConvolutionFP16CPUKernel::PreProcess() { if (!InferShapeDone()) { auto ret = (const_cast(primitive_))->InferShape(in_tensors_, out_tensors_); if (ret != RET_OK) { - (const_cast(primitive_))->SetInferFlag(false); + (const_cast(primitive_))->set_infer_flag(false); MS_LOG(ERROR) << "InferShape fail!"; return ret; } - (const_cast(primitive_))->SetInferFlag(true); + (const_cast(primitive_))->set_infer_flag(true); ret = ReSize(); if (ret != RET_OK) { MS_LOG(ERROR) << "ReSize fail!ret: " << ret; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc index e6bf733c4f..f1f7c3dda5 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc @@ -254,8 +254,8 @@ kernel::LiteKernel *CpuMatmulFp16KernelCreator(const std::vector auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc b/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc index f3b774e548..c16619b702 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc @@ -80,12 +80,12 @@ int QuantDTypeCastFp16CPUKernel::QuantDTypeCast(int task_id) { return RET_OK; } int thread_offset = task_id * thread_n_stride_; - if (in_tensors_.front()->GetQuantParams().empty() && out_tensors_.front()->GetQuantParams().empty()) { + if (in_tensors_.front()->quant_params().empty() && out_tensors_.front()->quant_params().empty()) { MS_LOG(ERROR) << "QuantDTypeCast need quantization parameters which is not found."; return RET_ERROR; } - auto quant_arg = !out_tensors_.front()->GetQuantParams().empty() ? out_tensors_.front()->GetQuantParams().front() - : in_tensors_.front()->GetQuantParams().front(); + auto quant_arg = !out_tensors_.front()->quant_params().empty() ? out_tensors_.front()->quant_params().front() + : in_tensors_.front()->quant_params().front(); int ret; MS_ASSERT(int8_ptr_); MS_ASSERT(float16_ptr_); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_fp32.cc index 4be999a401..ab2c00ad09 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_fp32.cc @@ -41,10 +41,10 @@ int ArithmeticCPUKernel::Init() { int ArithmeticCPUKernel::PreProcess() { if (!InferShapeDone()) { - (const_cast(primitive_))->SetInferFlag(true); + (const_cast(primitive_))->set_infer_flag(true); auto ret = (const_cast(primitive_))->InferShape(in_tensors_, out_tensors_); if (ret != 0) { - (const_cast(primitive_))->SetInferFlag(false); + (const_cast(primitive_))->set_infer_flag(false); MS_LOG(ERROR) << "InferShape fail!"; return ret; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc index e77d4a16c0..ee595aa960 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc @@ -230,7 +230,7 @@ kernel::LiteKernel *CpuGroupConvFp32KernelCreator(const std::vectorGetInferFlag(); + bool infered_flag = primitive != nullptr && primitive->infer_flag(); if (infered_flag) { int batch = inputs.front()->Batch(); @@ -331,7 +331,7 @@ kernel::LiteKernel *CpuGroupConvFp32KernelCreator(const std::vectorset_data_type(outputs.at(j)->data_type()); - tmp_out_tensor->SetFormat(outputs.at(j)->GetFormat()); + tmp_out_tensor->set_format(outputs.at(j)->format()); if (infered_flag) { tmp_out_tensor->set_shape(out_shape); ret = tmp_out_tensor->MallocData(); @@ -365,7 +365,7 @@ kernel::LiteKernel *CpuConvFp32KernelCreator(const std::vector & int group = conv_param->group_; bool use_winograd = false; int out_unit; - if (primitive != nullptr && primitive->GetInferFlag()) { + if (primitive != nullptr && primitive->infer_flag()) { conv_param->input_h_ = inputs.front()->Height(); conv_param->input_w_ = inputs.front()->Width(); conv_param->input_channel_ = inputs.front()->Channel(); @@ -379,8 +379,8 @@ kernel::LiteKernel *CpuConvFp32KernelCreator(const std::vector & auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise_fp32.cc index af4376c7ea..6e5931bdff 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise_fp32.cc @@ -205,8 +205,8 @@ kernel::LiteKernel *CpuDeconvDwFp32KernelCreator(const std::vectordata_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc index 1e312555c2..c43c13518b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc @@ -237,8 +237,8 @@ kernel::LiteKernel *CpuDeConvFp32KernelCreator(const std::vector auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/depth_to_space_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/depth_to_space_fp32.cc index 5c7e7fa339..6402034959 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/depth_to_space_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/depth_to_space_fp32.cc @@ -53,7 +53,7 @@ int DepthToSpaceCPUKernel::Run() { float *output_data = reinterpret_cast(output->MutableData()); auto in_shape = input->shape(); DepthToSpaceParameter *param = reinterpret_cast(op_parameter_); - if (input->GetFormat() == schema::Format::Format_NHWC) { + if (input->format() == schema::Format::Format_NHWC) { DepthToSpaceForNHWC(input_data, output_data, in_shape.data(), param); return RET_OK; } else { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/group_convolution_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/group_convolution_fp32.cc index 3922bfb0d8..043596bde9 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/group_convolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/group_convolution_fp32.cc @@ -72,11 +72,11 @@ int GroupConvolutionCPUKernel::PreProcess() { if (!InferShapeDone()) { auto ret = (const_cast(primitive_))->InferShape(in_tensors_, out_tensors_); if (ret != RET_OK) { - (const_cast(primitive_))->SetInferFlag(false); + (const_cast(primitive_))->set_infer_flag(false); MS_LOG(ERROR) << "InferShape fail!"; return ret; } - (const_cast(primitive_))->SetInferFlag(true); + (const_cast(primitive_))->set_infer_flag(true); ret = ReSize(); if (ret != RET_OK) { MS_LOG(ERROR) << "ReSize fail!ret: " << ret; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc index 25d603fed8..3c3a7530c0 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc @@ -344,8 +344,8 @@ kernel::LiteKernel *CpuMatmulFp32KernelCreator(const std::vector auto *weight_tensor = inputs.at(kWeightIndex); auto *restore_data = weight_tensor->data_c(); auto restore_type = weight_tensor->data_type(); - bool dequant_flag = !weight_tensor->GetQuantParams().empty() && weight_tensor->GetQuantParams().front().inited && - restore_data != nullptr; + bool dequant_flag = + !weight_tensor->quant_params().empty() && weight_tensor->quant_params().front().inited && restore_data != nullptr; if (dequant_flag) { auto *dequant_weight = kernel::DequantUtil::DequantWeight(weight_tensor); if (dequant_weight == nullptr) { diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc index e2c7fd1fb1..b9db450c6c 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_batch_fp32.cc @@ -37,7 +37,7 @@ int SpaceToBatchCPUKernel::Init() { int SpaceToBatchCPUKernel::ReSize() { auto input_tensor = in_tensors_.at(0); auto output_tensor = out_tensors_.at(0); - if (input_tensor->GetFormat() != schema::Format_NHWC) { + if (input_tensor->format() != schema::Format_NHWC) { MS_LOG(ERROR) << "space_to_batch only support NHWC now!"; return RET_FORMAT_ERR; } diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc index 0e02aa96b3..c7e14748aa 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/space_to_depth_fp32.cc @@ -45,7 +45,7 @@ int SpaceToDepthCPUKernel::Init() { } int SpaceToDepthCPUKernel::ReSize() { - if (in_tensors_[0]->GetFormat() != schema::Format::Format_NHWC) { + if (in_tensors_[0]->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "space_to_depth only support NHWC now!"; return RET_FORMAT_ERR; } @@ -87,7 +87,7 @@ int SpaceToDepthRun(void *cdata, int task_id) { int SpaceToDepthCPUKernel::Run() { input_ptr_ = reinterpret_cast(in_tensors_[0]->MutableData()); output_ptr_ = reinterpret_cast(out_tensors_[0]->MutableData()); - if (in_tensors_[0]->GetFormat() == schema::Format::Format_NHWC) { + if (in_tensors_[0]->format() == schema::Format::Format_NHWC) { auto ret = ParallelLaunch(this->context_->thread_pool_, SpaceToDepthRun, this, thread_h_num_); if (ret != RET_OK) { MS_LOG(ERROR) << "SpaceToDepth error error_code[" << ret << "]"; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc index 5a9ceae6a8..6745533188 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc @@ -37,12 +37,12 @@ int QuantizedAddCPUKernel::Init() { MS_ASSERT(input1); MS_ASSERT(output); - para_.input0_scale_ = input0->GetQuantParams().front().scale; - para_.input0_offset_ = input0->GetQuantParams().front().zeroPoint * -1; - para_.input1_scale_ = input1->GetQuantParams().front().scale; - para_.input1_offset_ = input1->GetQuantParams().front().zeroPoint * -1; - para_.output_scale_ = output->GetQuantParams().front().scale; - para_.output_offset_ = output->GetQuantParams().front().zeroPoint; + para_.input0_scale_ = input0->quant_params().front().scale; + para_.input0_offset_ = input0->quant_params().front().zeroPoint * -1; + para_.input1_scale_ = input1->quant_params().front().scale; + para_.input1_offset_ = input1->quant_params().front().zeroPoint * -1; + para_.output_scale_ = output->quant_params().front().scale; + para_.output_offset_ = output->quant_params().front().zeroPoint; const int left_shift = 20; // 1 << 20, 2/20 const double twice_max_input_scale = 2 * std::max(para_.input0_scale_, para_.input1_scale_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/argminmax_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/argminmax_int8.cc index d95b8b4ec3..f26d48b40b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/argminmax_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/argminmax_int8.cc @@ -38,12 +38,12 @@ int ArgMinMaxInt8CPUKernel::Init() { auto param = reinterpret_cast(op_parameter_); param->data_type_ = kNumberTypeInt8; auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); in_quant_arg_.scale_ = in_quant_args.front().scale; in_quant_arg_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); out_quant_arg_.scale_ = out_quant_args.front().scale; out_quant_arg_.zp_ = out_quant_args.front().zeroPoint; if (!InferShapeDone()) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc index c2690ab170..ffb363d225 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_int8.cc @@ -79,17 +79,17 @@ int ArithmeticInt8CPUKernel::Init() { } auto *input0_tensor = in_tensors_.at(0); - auto in0_quant_args = input0_tensor->GetQuantParams(); + auto in0_quant_args = input0_tensor->quant_params(); quant_args_.in0_args_.scale_ = in0_quant_args.front().scale; quant_args_.in0_args_.zp_ = in0_quant_args.front().zeroPoint; auto *input1_tensor = in_tensors_.at(1); - auto in1_quant_args = input1_tensor->GetQuantParams(); + auto in1_quant_args = input1_tensor->quant_params(); quant_args_.in1_args_.scale_ = in1_quant_args.front().scale; quant_args_.in1_args_.zp_ = in1_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); quant_args_.out_args_.scale_ = out_quant_args.front().scale; quant_args_.out_args_.zp_ = out_quant_args.front().zeroPoint; if (!InferShapeDone()) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.cc index dce0fa49e8..bdfc349ec4 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/arithmetic_self_int8.cc @@ -29,12 +29,12 @@ using mindspore::lite::RET_OK; namespace mindspore::kernel { int ArithmeticSelfInt8CPUKernel::Init() { auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); para_->quant_arg_.in_args_.scale_ = in_quant_args.front().scale; para_->quant_arg_.in_args_.zp_ = in_quant_args.front().zeroPoint * (-1); auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); para_->quant_arg_.out_args_.scale_ = out_quant_args.front().scale; para_->quant_arg_.out_args_.zp_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/batch_to_space_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/batch_to_space_int8.cc index c6c9c5b6ab..fd760b6094 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/batch_to_space_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/batch_to_space_int8.cc @@ -36,12 +36,12 @@ int BatchToSpaceInt8CPUKernel::Init() { return ret; } auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); in_quant_arg_.scale_ = in_quant_args.front().scale; in_quant_arg_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); out_quant_arg_.scale_ = out_quant_args.front().scale; out_quant_arg_.zp_ = out_quant_args.front().zeroPoint; if (!InferShapeDone()) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc index fad96cc86a..fe99533768 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc @@ -61,14 +61,14 @@ int BatchnormInt8CPUKernel::InitConstTensor() { } // compute alpha, beta; auto eps = batchnorm_param_->epsilon_; - auto zp_in = input->GetQuantParams().front().zeroPoint; - auto zp_mean = mean->GetQuantParams().front().zeroPoint; - auto zp_var = variance->GetQuantParams().front().zeroPoint; - auto zp_out = output->GetQuantParams().front().zeroPoint; - auto s_in = input->GetQuantParams().front().scale; - auto s_mean = mean->GetQuantParams().front().scale; - auto s_var = variance->GetQuantParams().front().scale; - auto s_out = output->GetQuantParams().front().scale; + auto zp_in = input->quant_params().front().zeroPoint; + auto zp_mean = mean->quant_params().front().zeroPoint; + auto zp_var = variance->quant_params().front().zeroPoint; + auto zp_out = output->quant_params().front().zeroPoint; + auto s_in = input->quant_params().front().scale; + auto s_mean = mean->quant_params().front().scale; + auto s_var = variance->quant_params().front().scale; + auto s_out = output->quant_params().front().scale; for (int i = 0; i < batchnorm_param_->channel_; ++i) { float tmp = s_out * sqrt(eps + s_var * (var_ptr[i] - zp_var)); @@ -105,18 +105,18 @@ int BatchnormInt8CPUKernel::InitFusedConstTensor() { } // compute alpha, beta; auto eps = batchnorm_param_->epsilon_; - auto zp_in = input->GetQuantParams().front().zeroPoint; - auto zp_scale = scale->GetQuantParams().front().zeroPoint; - auto zp_offset = offset->GetQuantParams().front().zeroPoint; - auto zp_mean = mean->GetQuantParams().front().zeroPoint; - auto zp_var = variance->GetQuantParams().front().zeroPoint; - auto zp_out = output->GetQuantParams().front().zeroPoint; - auto s_in = input->GetQuantParams().front().scale; - auto s_scale = scale->GetQuantParams().front().scale; - auto s_offset = offset->GetQuantParams().front().scale; - auto s_mean = mean->GetQuantParams().front().scale; - auto s_var = variance->GetQuantParams().front().scale; - auto s_out = output->GetQuantParams().front().scale; + auto zp_in = input->quant_params().front().zeroPoint; + auto zp_scale = scale->quant_params().front().zeroPoint; + auto zp_offset = offset->quant_params().front().zeroPoint; + auto zp_mean = mean->quant_params().front().zeroPoint; + auto zp_var = variance->quant_params().front().zeroPoint; + auto zp_out = output->quant_params().front().zeroPoint; + auto s_in = input->quant_params().front().scale; + auto s_scale = scale->quant_params().front().scale; + auto s_offset = offset->quant_params().front().scale; + auto s_mean = mean->quant_params().front().scale; + auto s_var = variance->quant_params().front().scale; + auto s_out = output->quant_params().front().scale; float mul_12 = s_in * s_scale; float mul_24 = s_scale * s_mean; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc index c086dacbc6..cae32f1224 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/concat_int8.cc @@ -46,13 +46,13 @@ int ConcatInt8CPUKernel::Init() { } for (size_t i = 0; i < input_num; i++) { auto *input_tensor = in_tensors_.at(i); - auto quant_args = input_tensor->GetQuantParams(); + auto quant_args = input_tensor->quant_params(); concat_param_->quant_arg_.in_args_[i].scale_ = quant_args.front().scale; concat_param_->quant_arg_.in_args_[i].zp_ = quant_args.front().zeroPoint; } auto output_tensor = out_tensors_.at(kOutputIndex); - auto quant_args = output_tensor->GetQuantParams(); + auto quant_args = output_tensor->quant_params(); concat_param_->quant_arg_.out_args_.scale_ = quant_args.front().scale; concat_param_->quant_arg_.out_args_.zp_ = quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc index 799955ee5b..210422a832 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc @@ -171,18 +171,17 @@ kernel::LiteKernel *CpuConvDwInt8KernelCreator(const std::vector MS_ASSERT(opParameter != nullptr); MS_ASSERT(desc.type == schema::PrimitiveType_DepthwiseConv2D); kernel::LiteKernel *kernel = nullptr; - auto act_quant_size = - MSMAX(inputs[kInputIndex]->GetQuantParams().size(), outputs[kOutputIndex]->GetQuantParams().size()); + auto act_quant_size = MSMAX(inputs[kInputIndex]->quant_params().size(), outputs[kOutputIndex]->quant_params().size()); if (act_quant_size == 1) { // per tensor auto conv_param = reinterpret_cast(opParameter); - if (primitive != nullptr && primitive->GetInferFlag()) { + if (primitive != nullptr && primitive->infer_flag()) { conv_param->input_h_ = inputs[kInputIndex]->Height(); conv_param->input_w_ = inputs[kInputIndex]->Width(); conv_param->input_channel_ = inputs[kInputIndex]->Channel(); conv_param->output_h_ = outputs[kOutputIndex]->Height(); conv_param->output_w_ = outputs[kOutputIndex]->Width(); } - auto weight_quant_size = inputs[kWeightIndex]->GetQuantParams().size(); + auto weight_quant_size = inputs[kWeightIndex]->quant_params().size(); if (CheckIfUse3X3(conv_param) && weight_quant_size == 1) { #ifdef ENABLE_ARM64 kernel = diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_slidewindow_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_slidewindow_int8.cc index 79bb997f88..88cd2e8e98 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_slidewindow_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_slidewindow_int8.cc @@ -162,15 +162,15 @@ int ConvolutionDepthwiseSWInt8CPUKernel::ReinitQuantParam() { MS_LOG(ERROR) << "malloc input_zp_ failed."; return RET_ERROR; } - if (input_tensor->GetQuantParams().size() == kPerTensor) { + if (input_tensor->quant_params().size() == kPerTensor) { for (int i = 0; i < channel; i++) { - auto input_quant_arg = input_tensor->GetQuantParams().front(); + auto input_quant_arg = input_tensor->quant_params().front(); input_zp_[i] = input_quant_arg.zeroPoint; input_scale_[i] = input_quant_arg.scale; } } else { for (int i = 0; i < channel; i++) { - auto input_quant_arg = input_tensor->GetQuantParams()[i]; + auto input_quant_arg = input_tensor->quant_params()[i]; input_zp_[i] = input_quant_arg.zeroPoint; input_scale_[i] = input_quant_arg.scale; } @@ -187,15 +187,15 @@ int ConvolutionDepthwiseSWInt8CPUKernel::ReinitQuantParam() { MS_LOG(ERROR) << "malloc output_zp_ failed."; return RET_ERROR; } - if (output_tensor->GetQuantParams().size() == kPerTensor) { + if (output_tensor->quant_params().size() == kPerTensor) { for (int i = 0; i < channel; i++) { - auto output_quant_arg = output_tensor->GetQuantParams().front(); + auto output_quant_arg = output_tensor->quant_params().front(); output_zp_[i] = output_quant_arg.zeroPoint; output_scale_[i] = output_quant_arg.scale; } } else { for (int i = 0; i < channel; i++) { - auto output_quant_arg = output_tensor->GetQuantParams()[i]; + auto output_quant_arg = output_tensor->quant_params()[i]; output_zp_[i] = output_quant_arg.zeroPoint; output_scale_[i] = output_quant_arg.scale; } @@ -238,14 +238,14 @@ int ConvolutionDepthwiseSWInt8CPUKernel::ReinitQuantParam() { return RET_ERROR; } auto weight_tensor = in_tensors_.at(kWeightIndex); - if (weight_tensor->GetQuantParams().size() == kPerTensor) { + if (weight_tensor->quant_params().size() == kPerTensor) { for (int i = 0; i < channel; i++) { - auto weight_quant_arg = weight_tensor->GetQuantParams().front(); + auto weight_quant_arg = weight_tensor->quant_params().front(); weight_scale_[i] = weight_quant_arg.scale; } } else { for (int i = 0; i < channel; i++) { - auto weight_quant_arg = weight_tensor->GetQuantParams()[i]; + auto weight_quant_arg = weight_tensor->quant_params()[i]; weight_scale_[i] = weight_quant_arg.scale; } } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.cc index 6362e7c69d..bbf0a89c76 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/crop_int8.cc @@ -37,12 +37,12 @@ int CropInt8CPUKernel::Init() { return ret; } auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); crop_para_->quant_arg.in_args_.scale_ = in_quant_args.front().scale; crop_para_->quant_arg.in_args_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); crop_para_->quant_arg.out_args_.scale_ = out_quant_args.front().scale; crop_para_->quant_arg.out_args_.zp_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/depth_to_space_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/depth_to_space_int8.cc index 48ed6aa614..d541dfd25b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/depth_to_space_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/depth_to_space_int8.cc @@ -39,12 +39,12 @@ int DepthToSpaceInt8CPUKernel::Init() { param->data_type_size_ = sizeof(int8_t); auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); in_quant_arg_.scale_ = in_quant_args.front().scale; in_quant_arg_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); out_quant_arg_.scale_ = out_quant_args.front().scale; out_quant_arg_.zp_ = out_quant_args.front().zeroPoint; if (!InferShapeDone()) { diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/detection_post_process_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/detection_post_process_int8.cc index 7290eae7c2..211691504b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/detection_post_process_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/detection_post_process_int8.cc @@ -56,11 +56,11 @@ int DetectionPostProcessInt8CPUKernel::Dequantize(lite::Tensor *tensor, float ** MS_LOG(ERROR) << "Malloc data failed."; return RET_ERROR; } - if (tensor->GetQuantParams().empty()) { + if (tensor->quant_params().empty()) { MS_LOG(ERROR) << "null quant param"; return RET_ERROR; } - quant_param_ = tensor->GetQuantParams().front(); + quant_param_ = tensor->quant_params().front(); data_fp32_ = *data; quant_size_ = tensor->ElementsNum(); thread_n_stride_ = UP_DIV(quant_size_, op_parameter_->thread_num_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/div_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/div_int8.cc index fdd5f622f3..ef3e513d3b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/div_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/div_int8.cc @@ -39,12 +39,12 @@ int DivInt8CPUKernel::Init() { broadcast_ = input0->ElementsNum() != input1->ElementsNum(); - param_.in0_args_.scale_ = input0->GetQuantParams().front().scale; - param_.in0_args_.zp_ = -input0->GetQuantParams().front().zeroPoint; - param_.in1_args_.scale_ = input1->GetQuantParams().front().scale; - param_.in1_args_.zp_ = -input1->GetQuantParams().front().zeroPoint; - param_.out_args_.scale_ = output->GetQuantParams().front().scale; - param_.out_args_.zp_ = output->GetQuantParams().front().zeroPoint; + param_.in0_args_.scale_ = input0->quant_params().front().scale; + param_.in0_args_.zp_ = -input0->quant_params().front().zeroPoint; + param_.in1_args_.scale_ = input1->quant_params().front().scale; + param_.in1_args_.zp_ = -input1->quant_params().front().zeroPoint; + param_.out_args_.scale_ = output->quant_params().front().scale; + param_.out_args_.zp_ = output->quant_params().front().zeroPoint; const double real_multiplier = param_.in0_args_.scale_ / (param_.in1_args_.scale_ * param_.out_args_.scale_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc index b7bfd5459f..73b3e7873d 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc @@ -81,17 +81,17 @@ int FullconnectionInt8CPUKernel::ReSize() { } auto input_tensor = in_tensors_[0]; - auto params = input_tensor->GetQuantParams(); + auto params = input_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.input.zp_ = params.front().zeroPoint; quant_params_.input.scale_ = params.front().scale; auto weight_tensor = in_tensors_[1]; - params = weight_tensor->GetQuantParams(); + params = weight_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.weight.zp_ = params.front().zeroPoint; quant_params_.weight.scale_ = params.front().scale; auto output_tensor = out_tensors_[0]; - params = output_tensor->GetQuantParams(); + params = output_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.output.zp_ = params.front().zeroPoint; quant_params_.output.scale_ = params.front().scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc index 3a45ae3e32..e1224c6c2a 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc @@ -50,9 +50,9 @@ int GatherNdInt8CPUKernel::ReSize() { free(in_offset_); in_offset_ = nullptr; } - auto in_quant_args = in_tensors_.at(0)->GetQuantParams(); - auto ind_quant_args = in_tensors_.at(1)->GetQuantParams(); - auto out_quant_args = out_tensors_.at(0)->GetQuantParams(); + auto in_quant_args = in_tensors_.at(0)->quant_params(); + auto ind_quant_args = in_tensors_.at(1)->quant_params(); + auto out_quant_args = out_tensors_.at(0)->quant_params(); param_.alpha_ = in_quant_args.front().scale / out_quant_args.front().scale; param_.zp_in_ = in_quant_args.front().zeroPoint; param_.zp_out_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc index 291f65661d..182b15a1a2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc @@ -34,8 +34,8 @@ namespace mindspore::kernel { int GatherInt8CPUKernel::Init() { axis_ = (reinterpret_cast(op_parameter_))->axis_; batchDims_ = (reinterpret_cast(op_parameter_))->batchDims_; - auto in_quant_args = in_tensors_.at(0)->GetQuantParams(); - auto out_quant_args = out_tensors_.at(0)->GetQuantParams(); + auto in_quant_args = in_tensors_.at(0)->quant_params(); + auto out_quant_args = out_tensors_.at(0)->quant_params(); param_.alpha_ = in_quant_args.front().scale / out_quant_args.front().scale; param_.zp_in_ = in_quant_args.front().zeroPoint; param_.zp_out_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/hswish_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/hswish_int8.cc index db2b1da462..ac5ebc9cdc 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/hswish_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/hswish_int8.cc @@ -35,10 +35,10 @@ int HswishInt8CPUKernel::Init() { MS_ASSERT(input); MS_ASSERT(output); - quant_arg_.input_scale = input->GetQuantParams().front().scale; - quant_arg_.input_zp = input->GetQuantParams().front().zeroPoint; - quant_arg_.output_scale = output->GetQuantParams().front().scale; - quant_arg_.output_zp = output->GetQuantParams().front().zeroPoint; + quant_arg_.input_scale = input->quant_params().front().scale; + quant_arg_.input_zp = input->quant_params().front().zeroPoint; + quant_arg_.output_scale = output->quant_params().front().scale; + quant_arg_.output_zp = output->quant_params().front().zeroPoint; const float output_multiplier = (1.0f / 128.0f) * quant_arg_.input_scale / quant_arg_.output_scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc index 3ff3f86268..de5aafc4ee 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/l2_norm_int8.cc @@ -30,10 +30,10 @@ int L2NormInt8CPUKernel::Init() { MS_ASSERT(input); MS_ASSERT(output); - quant_param_.in_.scale_ = input->GetQuantParams().front().scale; - quant_param_.in_.zp_ = input->GetQuantParams().front().zeroPoint; - quant_param_.out_.scale_ = output->GetQuantParams().front().scale; - quant_param_.out_.zp_ = output->GetQuantParams().front().zeroPoint; + quant_param_.in_.scale_ = input->quant_params().front().scale; + quant_param_.in_.zp_ = input->quant_params().front().zeroPoint; + quant_param_.out_.scale_ = output->quant_params().front().scale; + quant_param_.out_.zp_ = output->quant_params().front().zeroPoint; return ReSize(); } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/layer_norm_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/layer_norm_int8.cc index e8a4c947af..113b2863f1 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/layer_norm_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/layer_norm_int8.cc @@ -26,18 +26,18 @@ void LayerNormInt8CPUKernel::SetQuantArgs() { lite::Tensor *input = in_tensors_.at(0); lite::Tensor *output = out_tensors_.at(0); - quant_param_.in_quant_arg_.zp_ = input->GetQuantParams().front().zeroPoint; - quant_param_.in_quant_arg_.scale_ = input->GetQuantParams().front().scale; - quant_param_.out_quant_arg_.zp_ = output->GetQuantParams().front().zeroPoint; - quant_param_.out_quant_arg_.scale_ = output->GetQuantParams().front().scale; + quant_param_.in_quant_arg_.zp_ = input->quant_params().front().zeroPoint; + quant_param_.in_quant_arg_.scale_ = input->quant_params().front().scale; + quant_param_.out_quant_arg_.zp_ = output->quant_params().front().zeroPoint; + quant_param_.out_quant_arg_.scale_ = output->quant_params().front().scale; quant_param_.output_activation_min_ = std::numeric_limits::min(); quant_param_.output_activation_max_ = std::numeric_limits::max(); if (param_->elementwise_affine_) { lite::Tensor *gamma_tensor = out_tensors_.at(1); - quant_param_.gamma_quant_arg_.zp_ = gamma_tensor->GetQuantParams().front().zeroPoint; - quant_param_.gamma_quant_arg_.scale_ = gamma_tensor->GetQuantParams().front().scale; + quant_param_.gamma_quant_arg_.zp_ = gamma_tensor->quant_params().front().zeroPoint; + quant_param_.gamma_quant_arg_.scale_ = gamma_tensor->quant_params().front().scale; } double in_scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc index 521839b8e0..eff4621bbf 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/leaky_relu_int8.cc @@ -51,12 +51,12 @@ int LeakyReluInt8CPUKernel::Init() { quant_prelu_parm_.slope_ = reinterpret_cast(op_parameter_)->alpha_; auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); quant_prelu_parm_.quant_arg.in_args_.scale_ = in_quant_args.front().scale; quant_prelu_parm_.quant_arg.in_args_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); quant_prelu_parm_.quant_arg.out_args_.scale_ = out_quant_args.front().scale; quant_prelu_parm_.quant_arg.out_args_.zp_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc index 3dd81a1eac..ebea63b8a3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc @@ -78,17 +78,17 @@ int MatmulInt8CPUKernel::ReSize() { thread_stride_ = UP_DIV(UP_DIV(params_->col_4_, 4), thread_count_); auto input_tensor = in_tensors_[0]; - auto params = input_tensor->GetQuantParams(); + auto params = input_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.input.zp_ = params.front().zeroPoint; quant_params_.input.scale_ = params.front().scale; auto weight_tensor = in_tensors_[1]; - params = weight_tensor->GetQuantParams(); + params = weight_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.weight.zp_ = params.front().zeroPoint; quant_params_.weight.scale_ = params.front().scale; auto output_tensor = out_tensors_[0]; - params = output_tensor->GetQuantParams(); + params = output_tensor->quant_params(); MS_ASSERT(params.size() == 1); quant_params_.output.zp_ = params.front().zeroPoint; quant_params_.output.scale_ = params.front().scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc index 68cd32f59b..7012d68054 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/mul_int8.cc @@ -37,12 +37,12 @@ int MulInt8CPUKernel::Init() { MS_ASSERT(input1); MS_ASSERT(output); - para_.mul_quant_arg_.in_quant_args_[0].scale_ = input0->GetQuantParams().front().scale; - para_.mul_quant_arg_.in_quant_args_[0].zp_ = input0->GetQuantParams().front().zeroPoint * -1; - para_.mul_quant_arg_.in_quant_args_[1].scale_ = input1->GetQuantParams().front().scale; - para_.mul_quant_arg_.in_quant_args_[1].zp_ = input1->GetQuantParams().front().zeroPoint * -1; - para_.mul_quant_arg_.out_quant_arg_.scale_ = output->GetQuantParams().front().scale; - para_.mul_quant_arg_.out_quant_arg_.zp_ = output->GetQuantParams().front().zeroPoint; + para_.mul_quant_arg_.in_quant_args_[0].scale_ = input0->quant_params().front().scale; + para_.mul_quant_arg_.in_quant_args_[0].zp_ = input0->quant_params().front().zeroPoint * -1; + para_.mul_quant_arg_.in_quant_args_[1].scale_ = input1->quant_params().front().scale; + para_.mul_quant_arg_.in_quant_args_[1].zp_ = input1->quant_params().front().zeroPoint * -1; + para_.mul_quant_arg_.out_quant_arg_.scale_ = output->quant_params().front().scale; + para_.mul_quant_arg_.out_quant_arg_.zp_ = output->quant_params().front().zeroPoint; para_.mul_quant_arg_.output_activation_max_ = std::numeric_limits::max(); para_.mul_quant_arg_.output_activation_min_ = std::numeric_limits::min(); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc index df64fe3670..3f8ac91f4a 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc @@ -67,8 +67,8 @@ int PadInt8CPUKernel::SetQuantParam() { auto *input_tensor = in_tensors_.at(kInputIndex); auto *out_tensor = out_tensors_.at(kOutputIndex); - auto in_quant_arg = input_tensor->GetQuantParams(); - auto out_quant_arg = out_tensor->GetQuantParams(); + auto in_quant_arg = input_tensor->quant_params(); + auto out_quant_arg = out_tensor->quant_params(); pad_quant_args->in_quant_args_->zp_ = in_quant_arg.front().zeroPoint; pad_quant_args->in_quant_args_->scale_ = in_quant_arg.front().scale; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc index 117d7bc488..946bbec6cb 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/power_int8.cc @@ -41,11 +41,11 @@ int PowerInt8CPUKernel::Init() { MS_ASSERT(input); MS_ASSERT(output); - auto in_quant_args = input->GetQuantParams(); + auto in_quant_args = input->quant_params(); param_->quant_arg_.in_args_.scale_ = in_quant_args.front().scale; param_->quant_arg_.in_args_.zp_ = in_quant_args.front().zeroPoint; - auto out_quant_args = output->GetQuantParams(); + auto out_quant_args = output->quant_params(); param_->quant_arg_.out_args_.scale_ = out_quant_args.front().scale; param_->quant_arg_.out_args_.zp_ = out_quant_args.front().zeroPoint; @@ -71,7 +71,7 @@ int PowerInt8CPUKernel::DoPower(int task_id) { param_->broadcast_ = true; if (in_tensors_.size() == 2) { auto exp_tensor = in_tensors_.at(1); - auto exp_quant_args = exp_tensor->GetQuantParams(); + auto exp_quant_args = exp_tensor->quant_params(); param_->quant_arg_.exp_args_.scale_ = exp_quant_args.front().scale; param_->quant_arg_.exp_args_.zp_ = exp_quant_args.front().zeroPoint; exp_ptr = reinterpret_cast(exp_tensor->MutableData()); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc index 92a8fe5db4..e76a704944 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc @@ -102,10 +102,10 @@ int ReduceInt8CPUKernel::CalculateQuantArgs() { MS_ASSERT(input); MS_ASSERT(output); - quant_arg_.in_scale_ = input->GetQuantParams().front().scale; - quant_arg_.in_zp_ = input->GetQuantParams().front().zeroPoint; - quant_arg_.out_scale_ = output->GetQuantParams().front().scale; - quant_arg_.out_zp_ = output->GetQuantParams().front().zeroPoint; + quant_arg_.in_scale_ = input->quant_params().front().scale; + quant_arg_.in_zp_ = input->quant_params().front().zeroPoint; + quant_arg_.out_scale_ = output->quant_params().front().scale; + quant_arg_.out_zp_ = output->quant_params().front().zeroPoint; // (quant_out - out_zp) * out_scale = (quant_in - in_zp) * in_scale const double input_output_multiplier = quant_arg_.in_scale_ / quant_arg_.out_scale_; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc index 95afe7e96e..45fb4b50de 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/relux_int8.cc @@ -33,10 +33,10 @@ int ReluXInt8CPUKernel::Init() { MS_ASSERT(input); MS_ASSERT(output); - quant_arg_.input_arg.scale_ = input->GetQuantParams().front().scale; - quant_arg_.input_arg.zp_ = input->GetQuantParams().front().zeroPoint; - quant_arg_.output_arg.scale_ = output->GetQuantParams().front().scale; - quant_arg_.output_arg.zp_ = output->GetQuantParams().front().zeroPoint; + quant_arg_.input_arg.scale_ = input->quant_params().front().scale; + quant_arg_.input_arg.zp_ = input->quant_params().front().zeroPoint; + quant_arg_.output_arg.scale_ = output->quant_params().front().scale; + quant_arg_.output_arg.zp_ = output->quant_params().front().zeroPoint; const double multiplier = quant_arg_.input_arg.scale_ / quant_arg_.output_arg.scale_; QuantizeRoundParameter(multiplier, &quant_arg_.input_multiplier_, &quant_arg_.left_shift_, &quant_arg_.right_shift_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc index 3f6f3ffb49..39a3faf083 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/reshape_int8.cc @@ -33,12 +33,12 @@ namespace mindspore::kernel { int ReshapeInt8CPUKernel::Init() { ReshapeBaseCPUKernel::Init(); auto *input_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); reshape_param_->quant_para_.in_args_.scale_ = in_quant_args.front().scale; reshape_param_->quant_para_.in_args_.zp_ = in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); reshape_param_->quant_para_.out_args_.scale_ = out_quant_args.front().scale; reshape_param_->quant_para_.out_args_.zp_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc index b8710e2f73..31a71ff1ce 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc @@ -42,11 +42,11 @@ int ResizeInt8CPUKernel::Init() { quant_out_ = new (std::nothrow) QuantArg; MS_ASSERT(quant_out_); auto input = in_tensors_.at(0); - quant_in_->zp_ = input->GetQuantParams().front().zeroPoint; - quant_in_->scale_ = input->GetQuantParams().front().scale; + quant_in_->zp_ = input->quant_params().front().zeroPoint; + quant_in_->scale_ = input->quant_params().front().scale; auto output = out_tensors_.at(0); - quant_out_->zp_ = output->GetQuantParams().front().zeroPoint; - quant_out_->scale_ = output->GetQuantParams().front().scale; + quant_out_->zp_ = output->quant_params().front().zeroPoint; + quant_out_->scale_ = output->quant_params().front().scale; multiplier_ = new (std::nothrow) QuantMulArg; MS_ASSERT(multiplier_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc index eafb208fe8..b086af679e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/scale_int8.cc @@ -175,12 +175,12 @@ int ScaleInt8CPUKernel::InitQuantArgs() { auto input = in_tensors_.at(0); auto scale = in_tensors_.at(1); auto output = out_tensors_.at(0); - auto input_scale = input->GetQuantParams().front().scale; - auto scale_scale = scale->GetQuantParams().front().scale; - auto output_scale = output->GetQuantParams().front().scale; - scale_param_->input_zp_ = input->GetQuantParams().front().zeroPoint; - scale_param_->scale_zp_ = scale->GetQuantParams().front().zeroPoint; - scale_param_->output_zp_ = output->GetQuantParams().front().zeroPoint; + auto input_scale = input->quant_params().front().scale; + auto scale_scale = scale->quant_params().front().scale; + auto output_scale = output->quant_params().front().scale; + scale_param_->input_zp_ = input->quant_params().front().zeroPoint; + scale_param_->scale_zp_ = scale->quant_params().front().zeroPoint; + scale_param_->output_zp_ = output->quant_params().front().zeroPoint; // (in * scale + offset) / output const double input_output_multiplier = input_scale * scale_scale / output_scale; @@ -191,8 +191,8 @@ int ScaleInt8CPUKernel::InitQuantArgs() { if (in_tensors_.size() == kScaleBiasInputsSize) { auto offset = in_tensors_.at(2); - auto offset_scale = offset->GetQuantParams().front().scale; - scale_param_->offset_zp_ = offset->GetQuantParams().front().zeroPoint; + auto offset_scale = offset->quant_params().front().scale; + scale_param_->offset_zp_ = offset->quant_params().front().zeroPoint; const double offset_multiplier = offset_scale / output_scale; QuantizeMultiplier(offset_multiplier, &scale_param_->offset_mul_arg_.multiplier_, &shift); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc index 576ff4fc8c..8381ec4627 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/sigmoid_int8.cc @@ -50,10 +50,10 @@ void CalculateTableList(int8_t *table, const float input_scale, const int32_t in int SigmoidInt8CPUKernel::Init() { lite::Tensor *input = in_tensors_.at(0); lite::Tensor *output = out_tensors_.at(0); - const float input_scale = input->GetQuantParams().front().scale; - const int32_t input_zp = input->GetQuantParams().front().zeroPoint; - const float output_scale = output->GetQuantParams().front().scale; - const int32_t output_zp = output->GetQuantParams().front().zeroPoint; + const float input_scale = input->quant_params().front().scale; + const int32_t input_zp = input->quant_params().front().zeroPoint; + const float output_scale = output->quant_params().front().scale; + const int32_t output_zp = output->quant_params().front().zeroPoint; if (output_scale != (1.0f / 256) || output_zp != -128) { MS_LOG(ERROR) << "Output scale is : " << output_scale << ", should be 1/256. Output zp is : " << output_zp << ", should be -128."; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc index a83a23a903..914538f4d3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/slice_int8.cc @@ -34,11 +34,11 @@ int SliceInt8CPUKernel::Init() { MS_ASSERT(input); MS_ASSERT(output); - auto in_quant_args = input->GetQuantParams(); + auto in_quant_args = input->quant_params(); param_->quant_arg_.in_args_.scale_ = in_quant_args.front().scale; param_->quant_arg_.in_args_.zp_ = in_quant_args.front().zeroPoint; - auto out_quant_args = output->GetQuantParams(); + auto out_quant_args = output->quant_params(); param_->quant_arg_.out_args_.scale_ = out_quant_args.front().scale; param_->quant_arg_.out_args_.zp_ = out_quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc index eaec1fa38f..f331371ba6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/softmax_int8.cc @@ -40,14 +40,14 @@ int SoftmaxInt8CPUKernel::Init() { auto *input_tensor = in_tensors_.at(kInputIndex); MS_ASSERT(input_tensor); - auto in_quant_args = input_tensor->GetQuantParams(); + auto in_quant_args = input_tensor->quant_params(); quant_params_.in_quant_args_.scale_ = in_quant_args.front().scale; quant_params_.in_quant_args_.zp_ = -in_quant_args.front().zeroPoint; auto *out_tensor = out_tensors_.at(kOutputIndex); MS_ASSERT(out_tensor); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); quant_params_.out_quant_arg_.scale_ = out_quant_args.front().scale; quant_params_.out_quant_arg_.zp_ = -out_quant_args.front().zeroPoint; quant_params_.output_activation_min_ = std::numeric_limits::min(); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc index 1460f979b4..60f13f1dc4 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/space_to_batch_int8.cc @@ -31,11 +31,11 @@ int SpaceToBatchInt8CPUKernel::Run() { auto input_ptr = reinterpret_cast(input_tensor->MutableData()); auto output_ptr = reinterpret_cast(output_tensor->MutableData()); SpaceToBatchParameter *param = reinterpret_cast(this->op_parameter_); - if (output_tensor->GetQuantParams().empty()) { + if (output_tensor->quant_params().empty()) { MS_LOG(ERROR) << "SpaceToBatchInt8 need quantization parameters which is not found."; return RET_ERROR; } - auto quant_arg = output_tensor->GetQuantParams().front(); + auto quant_arg = output_tensor->quant_params().front(); if (param->need_paddings_) { padded_input_ = context_->allocator->Malloc(param->padded_input_element_num * sizeof(int8_t)); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc index c581975e7e..7e10122d5e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/split_int8.cc @@ -41,13 +41,13 @@ int SplitInt8CPUKernel::Init() { auto in_tensor = in_tensors_.at(kInputIndex); - auto in_quant_args = in_tensor->GetQuantParams(); + auto in_quant_args = in_tensor->quant_params(); param->quant_arg_.in_args_.scale_ = in_quant_args.front().scale; param->quant_arg_.in_args_.zp_ = in_quant_args.front().zeroPoint; MS_ASSERT(param->num_split_ == outputs_.size()); for (int i = 0; i < param->num_split_; i++) { auto *out_tensor = out_tensors_.at(i); - auto out_quant_args = out_tensor->GetQuantParams(); + auto out_quant_args = out_tensor->quant_params(); param->quant_arg_.out_args_[i].scale_ = out_quant_args.front().scale; param->quant_arg_.out_args_[i].zp_ = out_quant_args.front().zeroPoint; } diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc index 973f856ad2..98f83256e6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/squeeze_int8.cc @@ -68,7 +68,7 @@ int SqueezeInt8CPUKernel::Init() { for (size_t i = 0; i < input_num; i++) { auto *input_tensor = in_tensors_.at(i); - auto quant_args = input_tensor->GetQuantParams(); + auto quant_args = input_tensor->quant_params(); MS_ASSERT(quant_args.size() == 1); quant_Squeeze_parm_->in_quant_args_[i].scale_ = quant_args.front().scale; quant_Squeeze_parm_->in_quant_args_[i].zp_ = quant_args.front().zeroPoint; @@ -77,7 +77,7 @@ int SqueezeInt8CPUKernel::Init() { MS_ASSERT(outputs_.size() == 1); auto output_tensor = out_tensors_.at(0); MS_ASSERT(output_tensor != nullptr); - auto quant_args = output_tensor->GetQuantParams(); + auto quant_args = output_tensor->quant_params(); MS_ASSERT(quant_args.size() == 1); quant_Squeeze_parm_->out_quant_args_.scale_ = quant_args.front().scale; quant_Squeeze_parm_->out_quant_args_.zp_ = quant_args.front().zeroPoint; diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.cc index df85cd40ba..8f78476f62 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/sub_int8.cc @@ -40,12 +40,12 @@ int SubInt8CPUKernel::Init() { broadcast_ = input0->ElementsNum() != input1->ElementsNum(); - param_.in0_args_.scale_ = input0->GetQuantParams().front().scale; - param_.in0_args_.zp_ = -input0->GetQuantParams().front().zeroPoint; - param_.in1_args_.scale_ = input1->GetQuantParams().front().scale; - param_.in1_args_.zp_ = -input1->GetQuantParams().front().zeroPoint; - param_.out_args_.scale_ = output->GetQuantParams().front().scale; - param_.out_args_.zp_ = output->GetQuantParams().front().zeroPoint; + param_.in0_args_.scale_ = input0->quant_params().front().scale; + param_.in0_args_.zp_ = -input0->quant_params().front().zeroPoint; + param_.in1_args_.scale_ = input1->quant_params().front().scale; + param_.in1_args_.zp_ = -input1->quant_params().front().zeroPoint; + param_.out_args_.scale_ = output->quant_params().front().scale; + param_.out_args_.zp_ = output->quant_params().front().zeroPoint; const int left_shift = 20; const double twice_max_input_scale = 2 * std::max(param_.in0_args_.scale_, param_.in1_args_.scale_); diff --git a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc index 23ecb7909b..8dae1551c8 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/unsqueeze_int8.cc @@ -30,12 +30,12 @@ using mindspore::schema::PrimitiveType_Unsqueeze; namespace mindspore::kernel { int Unsqueezeint8CPUKernel::Init() { auto *input_tensor = in_tensors_.at(0); - auto quant_args = input_tensor->GetQuantParams(); + auto quant_args = input_tensor->quant_params(); MS_ASSERT(quant_args.size() == 1); Unsq_para_->quant_arg.in_quant_args_.scale_ = quant_args.front().scale; Unsq_para_->quant_arg.in_quant_args_.zp_ = quant_args.front().zeroPoint; - auto out_quant_args = input_tensor->GetQuantParams(); + auto out_quant_args = input_tensor->quant_params(); Unsq_para_->quant_arg.out_quant_args_.scale_ = out_quant_args.front().scale; Unsq_para_->quant_arg.out_quant_args_.zp_ = out_quant_args.front().zeroPoint; Unsq_para_->thread_count_ = thread_count_; diff --git a/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc b/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc index 8f19605b78..77736dece6 100644 --- a/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc +++ b/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc @@ -73,7 +73,7 @@ int ScaleOpenCLKernel::InitBuffer() { int plane = image2d_info.H * image2d_info.W; int channel = image2d_info.C; int batch = image2d_info.N; - if (in_tensors_[0]->GetFormat() == in_tensors_[1]->GetFormat()) { + if (in_tensors_[0]->format() == in_tensors_[1]->format()) { if (in_tensors_[0]->data_type() == in_tensors_[1]->data_type()) { scale_ptr_ = allocator->Malloc(in_tensors_[1]->ElementsNum(), img_size, in_tensors_[1]->data_c()); offset_ptr_ = allocator->Malloc(in_tensors_[2]->ElementsNum(), img_size, in_tensors_[2]->data_c()); @@ -82,8 +82,8 @@ int ScaleOpenCLKernel::InitBuffer() { << in_tensors_[0]->data_type(); return RET_ERROR; } - } else if (in_tensors_[0]->GetFormat() == schema::Format_NHWC) { - if (in_tensors_[1]->GetFormat() == schema::Format_NHWC) { + } else if (in_tensors_[0]->format() == schema::Format_NHWC) { + if (in_tensors_[1]->format() == schema::Format_NHWC) { if (in_tensors_[0]->data_type() == kNumberTypeFloat32) { auto *scale = new (std::nothrow) float[pack_weight_size]; if (scale == nullptr) { @@ -128,8 +128,8 @@ int ScaleOpenCLKernel::InitBuffer() { return RET_ERROR; } } else { - MS_LOG(ERROR) << "Unsupport format transpose from " << in_tensors_[1]->GetFormat() << "to " - << in_tensors_[0]->GetFormat(); + MS_LOG(ERROR) << "Unsupport format transpose from " << in_tensors_[1]->format() << "to " + << in_tensors_[0]->format(); return RET_ERROR; } } diff --git a/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc b/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc index c77acbc360..dcc3bb2314 100644 --- a/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc +++ b/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc @@ -49,10 +49,10 @@ int SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToNull( nullptr); if (mem_type == OpenCLMemType::IMG) { jv->set_in_tensors(tensors); - jv->SetInKernel(kernels); + jv->set_in_kernels(kernels); } else { jv->set_out_tensors(tensors); - jv->SetOutKernel(kernels); + jv->set_out_kernels(kernels); } } } @@ -80,11 +80,11 @@ int SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToConvert(const lite::Tensor tensors.emplace_back(new_tensor); } if (mem_type == OpenCLMemType::IMG) { - iv->SetInKernel(kernels); + iv->set_in_kernels(kernels); iv->set_in_tensors(tensors); in_opencl_op->AddOutKernel(iv); } else { - iv->SetOutKernel(kernels); + iv->set_out_kernels(kernels); iv->set_out_tensors(tensors); in_convert_op->AddInKernel(iv); } @@ -119,11 +119,11 @@ int SubGraphOpenCLKernel::GenToFormatOp(const std::vector &in_te } new_tensor->CopyTensor(*in_tensors[i]); if (mem_type == OpenCLMemType::IMG) { - new_tensor->SetFormat(dst_format); - in_tensors[i]->SetFormat(src_format); + new_tensor->set_format(dst_format); + in_tensors[i]->set_format(src_format); } else { - new_tensor->SetFormat(src_format); - in_tensors[i]->SetFormat(dst_format); + new_tensor->set_format(src_format); + in_tensors[i]->set_format(dst_format); } out_tensors->emplace_back(new_tensor); diff --git a/mindspore/lite/src/runtime/parallel_executor.cc b/mindspore/lite/src/runtime/parallel_executor.cc index 8030ff8685..c479907823 100644 --- a/mindspore/lite/src/runtime/parallel_executor.cc +++ b/mindspore/lite/src/runtime/parallel_executor.cc @@ -57,7 +57,7 @@ int ParallelExecutor::Run(std::vector &in_tensors, std::vectorGetFormat() != schema::Format::Format_NHWC) { + if (inTensor->format() != schema::Format::Format_NHWC) { MS_LOG(ERROR) << "Model input tensor should be NHWC"; return RET_ERROR; } diff --git a/mindspore/lite/src/scheduler.cc b/mindspore/lite/src/scheduler.cc index be2486f008..dfa2602f57 100644 --- a/mindspore/lite/src/scheduler.cc +++ b/mindspore/lite/src/scheduler.cc @@ -115,13 +115,13 @@ int Scheduler::InferShape(const lite::Model *model, std::vector *tenso MS_LOG(ERROR) << "Op " << node->name_ << " should exist in model!"; return RET_ERROR; } - primitive->SetInferFlag(!infer_shape_interrupt); + primitive->set_infer_flag(!infer_shape_interrupt); auto ret = primitive->InferShape(inputs, outputs); if (ret == RET_INFER_INVALID) { MS_LOG(INFO) << "InferShape shouldn't be done before runtime, name: " << node->name_ << ", type: " << schema::EnumNamePrimitiveType(static_cast(primitive->Type())) << "flag set to false."; - primitive->SetInferFlag(false); + primitive->set_infer_flag(false); infer_shape_interrupt = true; } else if (ret != RET_OK) { MS_LOG(ERROR) << "InferShape failed, name: " << node->name_ << ", type: " diff --git a/mindspore/lite/src/sub_graph_kernel.cc b/mindspore/lite/src/sub_graph_kernel.cc index 026824fc88..bfa37447ab 100644 --- a/mindspore/lite/src/sub_graph_kernel.cc +++ b/mindspore/lite/src/sub_graph_kernel.cc @@ -117,7 +117,7 @@ int SubGraphKernel::ReSize(bool is_interrupt) { MS_LOG(ERROR) << "all nodes in should be kernel"; return RET_ERROR; } - auto primitive = const_cast(kernel->GetPrimitive()); + auto primitive = const_cast(kernel->primitive()); if (primitive == nullptr) { MS_LOG(ERROR) << "kernel(" << kernel->name() << ")'s primitive is nullptr!"; return RET_ERROR; @@ -127,13 +127,13 @@ int SubGraphKernel::ReSize(bool is_interrupt) { for (auto &output : outputs) { output->FreeData(); } - primitive->SetInferFlag(!is_interrupt); + primitive->set_infer_flag(!is_interrupt); auto ret = primitive->InferShape(inputs, outputs); if (ret == RET_INFER_INVALID) { MS_LOG(INFO) << "InferShape shouldn't be done before runtime, type:" << schema::EnumNamePrimitiveType(static_cast(primitive->Type())) << "flag set to false."; - primitive->SetInferFlag(false); + primitive->set_infer_flag(false); is_interrupt = true; } else if (ret != RET_OK) { MS_LOG(ERROR) << "InferShape failed, type: " diff --git a/mindspore/lite/src/tensor.cc b/mindspore/lite/src/tensor.cc index ac49004506..55358e3901 100644 --- a/mindspore/lite/src/tensor.cc +++ b/mindspore/lite/src/tensor.cc @@ -35,13 +35,13 @@ Tensor::Tensor(const Tensor &tensor) { } } -int Tensor::CopyTensorData(const Tensor &srcTensor) { - if (srcTensor.data_ == nullptr) { - MS_LOG(ERROR) << "data of srcTensor is nullptr"; +int Tensor::CopyTensorData(const Tensor &src_tensor) { + if (src_tensor.data_ == nullptr) { + MS_LOG(ERROR) << "data of src_tensor is nullptr"; return RET_PARAM_INVALID; } size_t data_size = this->Size(); - MS_ASSERT(data_size == srcTensor.Size()); + MS_ASSERT(data_size == src_tensor.Size()); if (this->data_ == nullptr) { if (data_size > kMaxMallocSize) { MS_LOG(ERROR) << "Malloc size is too big while coping data, " << data_size << " bytes"; @@ -53,17 +53,17 @@ int Tensor::CopyTensorData(const Tensor &srcTensor) { return RET_ERROR; } } - memcpy(this->data_, srcTensor.data_, data_size); + memcpy(this->data_, src_tensor.data_, data_size); return RET_OK; } -int Tensor::CopyTensor(const Tensor &srcTensor, bool copyData) { - this->data_type_ = srcTensor.data_type_; - this->shape_ = srcTensor.shape_; - this->category_ = srcTensor.category_; - this->format_ = srcTensor.format_; - if (copyData) { - auto ret = CopyTensorData(srcTensor); +int Tensor::CopyTensor(const Tensor &src_tensor, bool copy_data) { + this->data_type_ = src_tensor.data_type_; + this->shape_ = src_tensor.shape_; + this->category_ = src_tensor.category_; + this->format_ = src_tensor.format_; + if (copy_data) { + auto ret = CopyTensorData(src_tensor); if (0 != ret) { MS_LOG(ERROR) << "CopyTensorData error"; return RET_ERROR; @@ -330,11 +330,11 @@ bool Tensor::IsScalar() { return this->category_ == CONST_SCALAR && this->data_ void Tensor::AddQuantParam(const QuantArg &quant_arg) { this->quant_params_.push_back(quant_arg); } -std::vector Tensor::GetQuantParams() const { return this->quant_params_; } +std::vector Tensor::quant_params() const { return this->quant_params_; } -std::vector Tensor::GetQuantClusters() const { return this->quant_clusters_; } +std::vector Tensor::quant_clusters() const { return this->quant_clusters_; } -void Tensor::SetQuantClusters(const std::vector &clusters) { this->quant_clusters_ = clusters; } +void Tensor::set_quant_clusters(const std::vector &clusters) { this->quant_clusters_ = clusters; } std::vector TensorVectorCast(const std::vector &src) { std::vector target(src.size()); diff --git a/mindspore/lite/src/tensor.h b/mindspore/lite/src/tensor.h index d5d16dc51c..2835695ad0 100644 --- a/mindspore/lite/src/tensor.h +++ b/mindspore/lite/src/tensor.h @@ -104,9 +104,9 @@ class Tensor : public mindspore::tensor::MSTensor { Category category() { return this->category_; } - void SetFormat(schema::Format format) { this->format_ = format; } + void set_format(schema::Format format) { this->format_ = format; } - schema::Format GetFormat() { return this->format_; } + schema::Format format() { return this->format_; } size_t ref_count() { return this->ref_count_; } @@ -118,11 +118,11 @@ class Tensor : public mindspore::tensor::MSTensor { void AddQuantParam(const QuantArg &quant_arg); - std::vector GetQuantParams() const; + std::vector quant_params() const; - std::vector GetQuantClusters() const; + std::vector quant_clusters() const; - void SetQuantClusters(const std::vector &clusters); + void set_quant_clusters(const std::vector &clusters); bool IsConst(); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc index 779d363b3c..fc61ba3eea 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32_tests.cc @@ -60,7 +60,7 @@ void InitConvDwCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); - input->SetFormat(schema::Format_NHWC); + input->set_format(schema::Format_NHWC); input->set_shape({conv_param->input_batch_, conv_param->input_h_, conv_param->input_w_, conv_param->input_channel_}); input->MallocData(); memcpy(input->MutableData(), input_data, input_size); @@ -91,7 +91,7 @@ void InitConvDwCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); output->set_shape( {conv_param->output_batch_, conv_param->output_h_, conv_param->output_w_, conv_param->output_channel_}); - output->SetFormat(schema::Format_NHWC); + output->set_format(schema::Format_NHWC); output->MallocData(); memset(output->MutableData(), 0, output->ElementsNum() * sizeof(float)); outputs->push_back(output); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/detection_post_process_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/detection_post_process_test.cc index 4e25d70f0f..2c8c0ca8a2 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/detection_post_process_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/detection_post_process_test.cc @@ -35,7 +35,7 @@ void DetectionPostProcessTestInit(std::vector *inputs_, std::vec reinterpret_cast(mindspore::lite::ReadFile(input_boxes_path.c_str(), &input_boxes_size)); auto *input_boxes = new lite::Tensor; input_boxes->set_data_type(kNumberTypeFloat32); - input_boxes->SetFormat(schema::Format_NHWC); + input_boxes->set_format(schema::Format_NHWC); input_boxes->set_shape({1, 1917, 4}); input_boxes->MallocData(); memcpy(input_boxes->MutableData(), input_boxes_data, input_boxes_size); @@ -47,7 +47,7 @@ void DetectionPostProcessTestInit(std::vector *inputs_, std::vec reinterpret_cast(mindspore::lite::ReadFile(input_scores_path.c_str(), &input_scores_size)); auto *input_scores = new lite::Tensor; input_scores->set_data_type(kNumberTypeFloat32); - input_scores->SetFormat(schema::Format_NHWC); + input_scores->set_format(schema::Format_NHWC); input_scores->set_shape({1, 1917, 91}); input_scores->MallocData(); memcpy(input_scores->MutableData(), input_scores_data, input_scores_size); @@ -63,7 +63,7 @@ void DetectionPostProcessTestInit(std::vector *inputs_, std::vec quant_arg.scale = 0.00645306; input_anchors->AddQuantParam(quant_arg); input_anchors->set_data_type(kNumberTypeUInt8); - input_anchors->SetFormat(schema::Format_NHWC); + input_anchors->set_format(schema::Format_NHWC); input_anchors->set_shape({1917, 4}); input_anchors->MallocData(); memcpy(input_anchors->MutableData(), input_anchors_data, input_anchors_size); @@ -72,28 +72,28 @@ void DetectionPostProcessTestInit(std::vector *inputs_, std::vec auto *output_boxes = new lite::Tensor; output_boxes->set_data_type(kNumberTypeFloat32); output_boxes->set_shape({1, 10, 4}); - output_boxes->SetFormat(schema::Format_NHWC); + output_boxes->set_format(schema::Format_NHWC); output_boxes->MallocData(); memset(output_boxes->MutableData(), 0, output_boxes->ElementsNum() * sizeof(float)); auto *output_classes = new lite::Tensor; output_classes->set_data_type(kNumberTypeFloat32); output_classes->set_shape({1, 10}); - output_classes->SetFormat(schema::Format_NHWC); + output_classes->set_format(schema::Format_NHWC); output_classes->MallocData(); memset(output_classes->MutableData(), 0, output_classes->ElementsNum() * sizeof(float)); auto *output_scores = new lite::Tensor; output_scores->set_data_type(kNumberTypeFloat32); output_scores->set_shape({1, 10}); - output_scores->SetFormat(schema::Format_NHWC); + output_scores->set_format(schema::Format_NHWC); output_scores->MallocData(); memset(output_scores->MutableData(), 0, output_scores->ElementsNum() * sizeof(float)); auto *output_num_det = new lite::Tensor; output_num_det->set_data_type(kNumberTypeFloat32); output_num_det->set_shape({1}); - output_num_det->SetFormat(schema::Format_NHWC); + output_num_det->set_format(schema::Format_NHWC); output_num_det->MallocData(); memset(output_num_det->MutableData(), 0, output_num_det->ElementsNum() * sizeof(float)); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc index 39546a0c10..dcd35f13f1 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/l2norm_fp32_test.cc @@ -49,7 +49,7 @@ void TestL2NormFp32::TearDown() { void TestL2NormFp32::Init(const std::vector &input_shape, const std::vector &output_shape, float *input_data, float *output_data, const int axis_num, ActType activation_type, const int thread_num) { in_tensor_.set_data_type(kNumberTypeFloat32); - in_tensor_.SetFormat(Format_NHWC); + in_tensor_.set_format(Format_NHWC); in_tensor_.set_shape(input_shape); out_tensor_.set_data_type(kNumberTypeFloat32); out_tensor_.set_shape(output_shape); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc index 472c70b88d..26edcdccf7 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/lstm_fp32_tests.cc @@ -51,7 +51,7 @@ void InitLstmForwardCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); - weight_i->SetFormat(schema::Format_NHWC); + weight_i->set_format(schema::Format_NHWC); weight_i->set_shape({1, lstm_param->hidden_size_ * 4, lstm_param->input_size_}); weight_i->MallocData(); memcpy(weight_i->MutableData(), weight_i_data.data(), weight_i_data.size() * sizeof(float)); @@ -64,7 +64,7 @@ void InitLstmForwardCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); - weight_h->SetFormat(schema::Format_NHWC); + weight_h->set_format(schema::Format_NHWC); weight_h->set_shape({1, lstm_param->hidden_size_ * 4, lstm_param->hidden_size_}); weight_h->MallocData(); memcpy(weight_h->MutableData(), weight_h_data.data(), weight_h_data.size() * sizeof(float)); @@ -76,7 +76,7 @@ void InitLstmForwardCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); - bias->SetFormat(schema::Format_NHWC); + bias->set_format(schema::Format_NHWC); bias->set_shape({1, lstm_param->hidden_size_ * 4 * 2}); bias->MallocData(); memcpy(bias->MutableData(), bias_data.data(), bias_data.size() * sizeof(float)); @@ -85,7 +85,7 @@ void InitLstmForwardCreator(std::vector *inputs, std::vector state_data = {0, 0, 0}; auto *state = new lite::Tensor; state->set_data_type(kNumberTypeFloat32); - state->SetFormat(schema::Format_NHWC); + state->set_format(schema::Format_NHWC); state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_}); state->MallocData(); memcpy(state->MutableData(), state_data.data(), state_data.size() * sizeof(float)); @@ -101,21 +101,21 @@ void InitLstmForwardCreator(std::vector *inputs, std::vectorset_data_type(kNumberTypeFloat32); output->set_shape({lstm_param->seq_len_, lstm_param->batch_, lstm_param->hidden_size_}); - output->SetFormat(schema::Format_NHWC); + output->set_format(schema::Format_NHWC); output->MallocData(); memset(output->MutableData(), 0, output->ElementsNum() * sizeof(float)); auto *cell_state = new lite::Tensor; cell_state->set_data_type(kNumberTypeFloat32); cell_state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_}); - cell_state->SetFormat(schema::Format_NHWC); + cell_state->set_format(schema::Format_NHWC); cell_state->MallocData(); memset(cell_state->MutableData(), 0, cell_state->ElementsNum() * sizeof(float)); auto *hidden_state = new lite::Tensor; hidden_state->set_data_type(kNumberTypeFloat32); hidden_state->set_shape({1, lstm_param->batch_, lstm_param->hidden_size_}); - hidden_state->SetFormat(schema::Format_NHWC); + hidden_state->set_format(schema::Format_NHWC); hidden_state->MallocData(); memset(hidden_state->MutableData(), 0, hidden_state->ElementsNum() * sizeof(float)); @@ -201,7 +201,7 @@ void InitLstmBackwardCreator(std::vector *inputs, std::vector
  • set_data_type(kNumberTypeFloat32); - weight_i->SetFormat(schema::Format_NHWC); + weight_i->set_format(schema::Format_NHWC); weight_i->set_shape({2, lstm_param->hidden_size_ * 4, lstm_param->input_size_}); weight_i->MallocData(); memcpy(weight_i->MutableData(), weight_i_data.data(), weight_i_data.size() * sizeof(float)); @@ -219,7 +219,7 @@ void InitLstmBackwardCreator(std::vector *inputs, std::vector
  • set_data_type(kNumberTypeFloat32); - weight_h->SetFormat(schema::Format_NHWC); + weight_h->set_format(schema::Format_NHWC); weight_h->set_shape({2, lstm_param->hidden_size_ * 4, lstm_param->hidden_size_}); weight_h->MallocData(); memcpy(weight_h->MutableData(), weight_h_data.data(), weight_h_data.size() * sizeof(float)); @@ -234,7 +234,7 @@ void InitLstmBackwardCreator(std::vector *inputs, std::vector
  • set_data_type(kNumberTypeFloat32); - bias->SetFormat(schema::Format_NHWC); + bias->set_format(schema::Format_NHWC); bias->set_shape({2, lstm_param->hidden_size_ * 4 * 2}); bias->MallocData(); memcpy(bias->MutableData(), bias_data.data(), bias_data.size() * sizeof(float)); @@ -243,7 +243,7 @@ void InitLstmBackwardCreator(std::vector *inputs, std::vector
  • state_data = {0, 0, 0, 0, 0, 0}; auto *state = new lite::Tensor; state->set_data_type(kNumberTypeFloat32); - state->SetFormat(schema::Format_NHWC); + state->set_format(schema::Format_NHWC); state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_}); state->MallocData(); memcpy(state->MutableData(), state_data.data(), state_data.size() * sizeof(float)); @@ -259,21 +259,21 @@ void InitLstmBackwardCreator(std::vector *inputs, std::vector
  • set_data_type(kNumberTypeFloat32); output->set_shape({lstm_param->seq_len_, 2, lstm_param->batch_, lstm_param->hidden_size_}); - output->SetFormat(schema::Format_NHWC); + output->set_format(schema::Format_NHWC); output->MallocData(); memset(output->MutableData(), 0, output->ElementsNum() * sizeof(float)); auto *cell_state = new lite::Tensor; cell_state->set_data_type(kNumberTypeFloat32); cell_state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_}); - cell_state->SetFormat(schema::Format_NHWC); + cell_state->set_format(schema::Format_NHWC); cell_state->MallocData(); memset(cell_state->MutableData(), 0, cell_state->ElementsNum() * sizeof(float)); auto *hidden_state = new lite::Tensor; hidden_state->set_data_type(kNumberTypeFloat32); hidden_state->set_shape({2, lstm_param->batch_, lstm_param->hidden_size_}); - hidden_state->SetFormat(schema::Format_NHWC); + hidden_state->set_format(schema::Format_NHWC); hidden_state->MallocData(); memset(hidden_state->MutableData(), 0, hidden_state->ElementsNum() * sizeof(float)); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc index 9ad141272c..cac9120e0b 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/non_max_suppression_fp32_tests.cc @@ -63,12 +63,12 @@ void TestNMSFp32::Init(const std::vector &box_tensor_shape, float *box_data const std::vector &score_tensor_shape, float *score_data, int32_t max_output, float iou_threshold, float score_threshold, int center_box_point) { box_tensor_.set_data_type(kNumberTypeFloat32); - box_tensor_.SetFormat(Format_NHWC); + box_tensor_.set_format(Format_NHWC); box_tensor_.set_shape(box_tensor_shape); box_tensor_.set_data(box_data); score_tensor_.set_data_type(kNumberTypeFloat32); - score_tensor_.SetFormat(Format_NHWC); + score_tensor_.set_format(Format_NHWC); score_tensor_.set_shape(score_tensor_shape); score_tensor_.set_data(score_data); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc index 94ad358748..99cb437480 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/pad_fp32_test.cc @@ -61,7 +61,7 @@ void TestPadFp32::Prepare(const std::vector &input_shape, const std::vector float *output_data, PaddingMode mode, int *paddings, int padding_length, float constant_value, const int thread_num) { in_tensor_.set_data_type(kNumberTypeFloat32); - in_tensor_.SetFormat(Format_NHWC); + in_tensor_.set_format(Format_NHWC); in_tensor_.set_shape(input_shape); out_tensor_.set_data_type(kNumberTypeFloat32); out_tensor_.set_shape(output_shape); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc index 6a4458fd0c..b6b9b216b1 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/resize_bilinear_fp32_tests.cc @@ -54,7 +54,7 @@ void TestResizeBilinearFp32::Prepare(const std::vector &input_shape, const float *input_data, float *output_data, const bool align_corners, const int thread_num) { in_tensor_.set_data_type(kNumberTypeFloat32); - in_tensor_.SetFormat(Format_NHWC); + in_tensor_.set_format(Format_NHWC); in_tensor_.set_shape(input_shape); out_tensor_.set_data_type(kNumberTypeFloat32); out_tensor_.set_shape(output_shape); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc index 970ae8461f..39dd842d5e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/scale_fp32_tests.cc @@ -66,13 +66,13 @@ void TestScaleFp32::Prepare(const std::vector &input_shape, const std::vect float *input_data, float *scale_data, float *offset_data, float *output_data, int axis, ActivationType act_type, const int thread_num) { in_tensor_.set_data_type(kNumberTypeFloat32); - in_tensor_.SetFormat(Format_NHWC); + in_tensor_.set_format(Format_NHWC); in_tensor_.set_shape(input_shape); scale_tensor_.set_data_type(kNumberTypeFloat32); - scale_tensor_.SetFormat(Format_NHWC); + scale_tensor_.set_format(Format_NHWC); scale_tensor_.set_shape(scale_shape); offset_tensor_.set_data_type(kNumberTypeFloat32); - offset_tensor_.SetFormat(Format_NHWC); + offset_tensor_.set_format(Format_NHWC); offset_tensor_.set_shape(offset_shape); out_tensor_.set_data_type(kNumberTypeFloat32); out_tensor_.set_shape(output_shape); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc index 8b29459961..fb8048e114 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/space_to_depth_fp32_tests.cc @@ -53,7 +53,7 @@ TEST_F(SpaceToDepthTestFp32, SpaceToDepthTest2) { lite::Tensor input_tensor; input_tensor.set_data(input.data()); input_tensor.set_shape(in_shape); - input_tensor.SetFormat(schema::Format_NHWC); + input_tensor.set_format(schema::Format_NHWC); input_tensor.set_data_type(kNumberTypeFloat32); std::vector inputs_tensor; inputs_tensor.push_back(&input_tensor); @@ -65,7 +65,7 @@ TEST_F(SpaceToDepthTestFp32, SpaceToDepthTest2) { lite::Tensor output_tensor; output_tensor.set_data(output.data()); output_tensor.set_shape(out_shape); - output_tensor.SetFormat(schema::Format_NHWC); + output_tensor.set_format(schema::Format_NHWC); output_tensor.set_data_type(kNumberTypeFloat32); std::vector outputs_tensor; outputs_tensor.push_back(&output_tensor); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc index 3f8d44d14e..13748becd5 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32/transpose_fp32_tests.cc @@ -185,7 +185,7 @@ TEST_F(TestTransposeFp32, TransposeFp32_test5) { lite::Tensor input_tensor; input_tensor.set_data(input.data()); input_tensor.set_shape(input_shape); - input_tensor.SetFormat(schema::Format_NHWC); + input_tensor.set_format(schema::Format_NHWC); input_tensor.set_data_type(kNumberTypeFloat32); std::vector inputs_tensor; inputs_tensor.emplace_back(&input_tensor); @@ -193,7 +193,7 @@ TEST_F(TestTransposeFp32, TransposeFp32_test5) { lite::Tensor output_tensor; output_tensor.set_data(output.data()); output_tensor.set_shape(output_shape); - output_tensor.SetFormat(schema::Format_NHWC); + output_tensor.set_format(schema::Format_NHWC); output_tensor.set_data_type(kNumberTypeFloat32); std::vector outputs_tensor; outputs_tensor.emplace_back(&output_tensor); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc index 080307b917..f631a5df9e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/int8/quant_dtype_cast_tests.cc @@ -43,7 +43,7 @@ TEST_F(QuantDTypeCastTestFp32, QuantDTypeCastTest1) { input_tensor.set_data(input.data()); input_tensor.set_shape(in_shape); input_tensor.set_data_type(kNumberTypeInt8); - input_tensor.SetFormat(schema::Format_NHWC); + input_tensor.set_format(schema::Format_NHWC); input_tensor.AddQuantParam(quant_arg); std::vector inputs_tensor; @@ -104,7 +104,7 @@ TEST_F(QuantDTypeCastTestFp32, QuantDTypeCastTest2) { lite::Tensor output_tensor; output_tensor.set_data(output.data()); output_tensor.set_shape(out_shape); - output_tensor.SetFormat(schema::Format_NHWC); + output_tensor.set_format(schema::Format_NHWC); output_tensor.set_data_type(kNumberTypeInt8); std::vector outputs_tensor; outputs_tensor.emplace_back(&output_tensor); diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/string/normalize.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/string/normalize.cc index 64357ce127..f1d1357f0e 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/string/normalize.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/string/normalize.cc @@ -47,7 +47,7 @@ class TestNormalize : public mindspore::CommonTest { void TestNormalize::NormalizeTestInit() { input_tensor_.set_data_type(kObjectTypeString); - input_tensor_.SetFormat(schema::Format_NHWC); + input_tensor_.set_format(schema::Format_NHWC); std::vector str_pack; const char sentence1[] = " I don't know what happened\n"; @@ -57,7 +57,7 @@ void TestNormalize::NormalizeTestInit() { mindspore::lite::WriteStringsToTensor(&input_tensor_, str_pack); output_tensor_.set_data_type(kObjectTypeString); - output_tensor_.SetFormat(schema::Format_NHWC); + output_tensor_.set_format(schema::Format_NHWC); } TEST_F(TestNormalize, TestSentence) { diff --git a/mindspore/lite/tools/anf_exporter/anf_exporter.cc b/mindspore/lite/tools/anf_exporter/anf_exporter.cc index e572857d8b..24b9359963 100644 --- a/mindspore/lite/tools/anf_exporter/anf_exporter.cc +++ b/mindspore/lite/tools/anf_exporter/anf_exporter.cc @@ -94,10 +94,10 @@ int AnfExporter::ConvertQuantParam(const std::unique_ptr &me MS_ASSERT(primitive != nullptr); MS_ASSERT(dst_node != nullptr); // add quant param - dst_node->quantType = primitive->GetQuantType(); + dst_node->quantType = primitive->quant_type(); MS_LOG(DEBUG) << "node: " << dst_node->name << " add QuantParam"; // activation - auto input_quant_params = primitive->GetInputQuantParams(); + auto input_quant_params = primitive->input_quant_params(); auto node_type = (schema::PrimitiveType)primitive->Type(); if (!input_quant_params.empty()) { for (size_t i = 0; i < input_quant_params.size(); i++) { @@ -124,7 +124,7 @@ int AnfExporter::ConvertQuantParam(const std::unique_ptr &me // output auto output_index = dst_node->outputIndex[0]; auto tensor_output = meta_graph->allTensors[output_index].get(); - auto output_quant_params = primitive->GetOutputQuantParams(); + auto output_quant_params = primitive->output_quant_params(); if (output_quant_params.empty()) { if (node_type != schema::PrimitiveType_QuantDTypeCast) { MS_LOG(DEBUG) << "node: " << dst_node->name << " output quant params is empty"; @@ -219,7 +219,7 @@ schema::MetaGraphT *AnfExporter::Export(const FuncGraphPtr &func_graph, bool kee #ifdef SUPPORT_TRAIN RemoveIfDepend(cnode); #endif - auto primT = primitive_c->GetPrimitiveT(); + auto primT = primitive_c->primitiveT(); auto node = std::make_unique(); if (node == nullptr) { MS_LOG(ERROR) << "object failed to be constructed"; diff --git a/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc b/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc index 285b1da80e..f38195472c 100644 --- a/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc +++ b/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc @@ -150,7 +150,7 @@ STATUS InferShapePass::Run(MetaGraphT *graph) { auto output_dims = output_tensors[i]->shape(); auto &output_tensor = graph->allTensors.at(node->outputIndex[i]); output_tensor->dims.swap(output_dims); - output_tensor->format = output_tensors[i]->GetFormat(); + output_tensor->format = output_tensors[i]->format(); output_tensor->dataType = output_tensors[i]->data_type(); } FreeTensors(input_tensors, output_tensors); diff --git a/mindspore/lite/tools/converter/quantizer/post_training_quantizer.cc b/mindspore/lite/tools/converter/quantizer/post_training_quantizer.cc index 9fe19fe86f..7b3ace1a38 100644 --- a/mindspore/lite/tools/converter/quantizer/post_training_quantizer.cc +++ b/mindspore/lite/tools/converter/quantizer/post_training_quantizer.cc @@ -671,7 +671,7 @@ STATUS PostTrainingQuantizer::DoBiasQuant(const AnfNodePtr &bias, const std::sha auto bias_default_param = bias_parameter_ptr->default_param(); auto bias_param = std::dynamic_pointer_cast(bias_default_param); MS_ASSERT(bias_parameter_ptr != nullptr); - auto active_weight_quant_params = primitive_c->GetInputQuantParams(); + auto active_weight_quant_params = primitive_c->input_quant_params(); if (active_weight_quant_params.size() != 2) { MS_LOG(ERROR) << "unexpected active_weight_quant_params size: " << active_weight_quant_params.size(); return RET_ERROR; @@ -743,7 +743,7 @@ STATUS PostTrainingQuantizer::DoBiasQuant(const AnfNodePtr &bias, const std::sha double filter_scale = std::abs(raw_datas[i]) / (activate_scale * quanted_bias_abs_limit); active_weight_quant_params[1][i].scale = filter_scale; active_weight_quant_params[1][i].zeroPoint = 0; - primitive_c->SetInputQuantParams(active_weight_quant_params); + primitive_c->set_input_quant_params(active_weight_quant_params); bias_scale_tmp = std::abs(raw_datas[i]) / quanted_bias_abs_limit; quant_params[i].scale = bias_scale_tmp; MS_LOG(DEBUG) << "new filter scale: " << filter_scale; @@ -796,7 +796,7 @@ STATUS PostTrainingQuantizer::QuantNode() { } if (inputs_diverg_info->find(op_name) == inputs_diverg_info->end()) { MS_LOG(INFO) << op_name << " can not do quant"; - primitive_c->SetQuantType(schema::QuantType_QUANT_NONE); + primitive_c->set_quant_type(schema::QuantType_QUANT_NONE); continue; } @@ -819,16 +819,16 @@ STATUS PostTrainingQuantizer::QuantNode() { MS_LOG(WARNING) << "input_cnode_primitive_c is null"; continue; } - if (input_cnode_primitive_c->GetOutputQuantParams().size() > index) { - auto quant_param = input_cnode_primitive_c->GetOutputQuantParams()[index]; + if (input_cnode_primitive_c->output_quant_params().size() > index) { + auto quant_param = input_cnode_primitive_c->output_quant_params()[index]; primitive_c->AddInputQuantParam(quant_param); primitive_c->AddOutputQuantParam(quant_param); } else { MS_LOG(WARNING) << "this TupleGetItem node's input node: " << input_cnode->fullname_with_scope() - << "'s output quant_params size: " << input_cnode_primitive_c->GetOutputQuantParams().size() + << "'s output quant_params size: " << input_cnode_primitive_c->output_quant_params().size() << ", but index: " << index; } - primitive_c->SetQuantType(schema::QuantType_PostTraining); + primitive_c->set_quant_type(schema::QuantType_PostTraining); continue; } else if (op_type != PrimitiveType_Conv2D && op_type != PrimitiveType_DepthwiseConv2D && op_type != PrimitiveType_DeConv2D && op_type != PrimitiveType_DeDepthwiseConv2D && @@ -851,7 +851,7 @@ STATUS PostTrainingQuantizer::QuantNode() { continue; } if (input_cnode_primitive_c->IsOutputQuantParamsInited()) { - auto quant_param = input_cnode_primitive_c->GetOutputQuantParams().front(); + auto quant_param = input_cnode_primitive_c->output_quant_params().front(); primitive_c->AddInputQuantParam(quant_param); } else { // do input quant @@ -929,7 +929,7 @@ STATUS PostTrainingQuantizer::QuantNode() { output_min_max.min = info->min; DoQuantOutput(output_scale, output_zp, &output_min_max, primitive_c); - primitive_c->SetQuantType(schema::QuantType_PostTraining); + primitive_c->set_quant_type(schema::QuantType_PostTraining); } } return RET_OK; @@ -1132,7 +1132,7 @@ STATUS PostTrainingQuantizer::Int8Inference() { } // do quantization: activation is always per layer quantized std::vector quant_datas; - auto quant_params = lite_tensor->GetQuantParams(); + auto quant_params = lite_tensor->quant_params(); if (quant_params.size() != 1) { MS_LOG(ERROR) << "unexpected quant_params size: " << quant_params.size(); return false; @@ -1190,7 +1190,7 @@ STATUS PostTrainingQuantizer::Int8Inference() { MS_LOG(ERROR) << "unexpected channels: 0"; return false; } - auto quant_params = lite_tensor->GetQuantParams(); + auto quant_params = lite_tensor->quant_params(); if (quant_params.size() != 1) { MS_LOG(ERROR) << "unexpected activatation quant_params size: " << quant_params.size(); return false; @@ -1361,7 +1361,7 @@ STATUS PostTrainingQuantizer::BiasCorrection(const FuncGraphPtr &func_graph) { MS_LOG(ERROR) << "primitive_c is nullptr"; continue; } - auto input_quant_params = primitive_c->GetInputQuantParams(); + auto input_quant_params = primitive_c->input_quant_params(); if (input_quant_params.size() == 3) { // compensate the existed @@ -1445,7 +1445,7 @@ STATUS PostTrainingQuantizer::BiasCorrection(const FuncGraphPtr &func_graph) { auto op_type = (schema::PrimitiveType)primitive_c->Type(); if (op_type == schema::PrimitiveType_Conv2D) { - auto conv2d = primitive_c->GetPrimitiveT()->value.AsConv2D(); + auto conv2d = primitive_c->primitiveT()->value.AsConv2D(); if (conv2d == nullptr) { MS_LOG(ERROR) << "conv2d is null"; delete[] tensor_data; @@ -1453,7 +1453,7 @@ STATUS PostTrainingQuantizer::BiasCorrection(const FuncGraphPtr &func_graph) { } conv2d->hasBias = true; } else if (op_type == schema::PrimitiveType_DepthwiseConv2D) { - auto depthwise_conv2d = primitive_c->GetPrimitiveT()->value.AsDepthwiseConv2D(); + auto depthwise_conv2d = primitive_c->primitiveT()->value.AsDepthwiseConv2D(); if (depthwise_conv2d == nullptr) { MS_LOG(ERROR) << "conv2d is null"; delete[] tensor_data; diff --git a/mindspore/lite/tools/converter/quantizer/quant_cast.cc b/mindspore/lite/tools/converter/quantizer/quant_cast.cc index 696b655511..dc57b25c2f 100644 --- a/mindspore/lite/tools/converter/quantizer/quant_cast.cc +++ b/mindspore/lite/tools/converter/quantizer/quant_cast.cc @@ -27,7 +27,7 @@ ValueNodePtr NewQuantCastValueNode(int src_type, int dst_type, const std::vector quant_dtype_cast.dstT = dst_type; // kNumberTypeFloat32; primitive->value.Set(quant_dtype_cast); auto primTValue = std::make_shared(primitive.release()); - primTValue->SetQuantType(schema::QuantType_PostTraining); + primTValue->set_quant_type(schema::QuantType_PostTraining); for (auto &quant_param : quant_params) { std::vector quant_params_in = {quant_param}; primTValue->AddInputQuantParam(quant_params_in); @@ -45,7 +45,7 @@ STATUS QuantCast::Run(const FuncGraphPtr &graph) { if (primitive_c == nullptr) { MS_LOG(WARNING) << "primitive_c is nullptr: " << cnode->fullname_with_scope(); } else { - curnode_quant_type = primitive_c->GetQuantType(); + curnode_quant_type = primitive_c->quant_type(); } for (size_t i = 1; i < cnode->inputs().size(); i++) { @@ -69,7 +69,7 @@ STATUS QuantCast::Run(const FuncGraphPtr &graph) { << " PrimitiveC is null"; continue; } - input_cnode_quant_type = input_cnode_primitive_c->GetQuantType(); + input_cnode_quant_type = input_cnode_primitive_c->quant_type(); } if (curnode_quant_type != input_cnode_quant_type) { @@ -77,11 +77,11 @@ STATUS QuantCast::Run(const FuncGraphPtr &graph) { if (curnode_quant_type == schema::QuantType_PostTraining && input_cnode_quant_type == schema::QuantType_QUANT_NONE) { value_node = - NewQuantCastValueNode(kNumberTypeFloat32, kNumberTypeInt8, primitive_c->GetInputQuantParams()[i - 1]); + NewQuantCastValueNode(kNumberTypeFloat32, kNumberTypeInt8, primitive_c->input_quant_params()[i - 1]); } else if (curnode_quant_type == schema::QuantType_QUANT_NONE && input_cnode_quant_type == schema::QuantType_PostTraining) { value_node = NewQuantCastValueNode(kNumberTypeInt8, kNumberTypeFloat32, - input_cnode_primitive_c->GetOutputQuantParams().front()); + input_cnode_primitive_c->output_quant_params().front()); } if (value_node == nullptr) { MS_LOG(WARNING) << "value_node is null! " diff --git a/mindspore/lite/tools/converter/quantizer/quantize_util.h b/mindspore/lite/tools/converter/quantizer/quantize_util.h index bcca548446..b8eaf9e00a 100644 --- a/mindspore/lite/tools/converter/quantizer/quantize_util.h +++ b/mindspore/lite/tools/converter/quantizer/quantize_util.h @@ -315,7 +315,7 @@ STATUS QuantFilter(const ParamValueLitePtr &weight, const std::shared_ptrAddInputQuantParam(quant_params); } else { - primitive_c->SetInputQuantParam(WEIGHT_INDEX, quant_params); + primitive_c->set_input_quant_param(WEIGHT_INDEX, quant_params); } return RET_OK; } diff --git a/mindspore/lite/tools/converter/quantizer/weight_quantizer.cc b/mindspore/lite/tools/converter/quantizer/weight_quantizer.cc index f61f5ed087..8eda191dec 100644 --- a/mindspore/lite/tools/converter/quantizer/weight_quantizer.cc +++ b/mindspore/lite/tools/converter/quantizer/weight_quantizer.cc @@ -130,7 +130,7 @@ STATUS WeightQuantizer::DoConvQuantize(const std::list &nodes) { } auto abstractTensor = utils::cast(abstractBase); abstractTensor->element()->set_type(TypeIdToType(type_id)); - primitive_c->SetQuantType(schema::QuantType_WeightQuant); + primitive_c->set_quant_type(schema::QuantType_WeightQuant); } return RET_OK; } @@ -208,7 +208,7 @@ STATUS WeightQuantizer::DoMulQuantize(const std::list &nodes) { } auto abstractTensor = utils::cast(abstractBase); abstractTensor->element()->set_type(TypeIdToType(type_id)); - primitive_c->SetQuantType(schema::QuantType_WeightQuant); + primitive_c->set_quant_type(schema::QuantType_WeightQuant); } return RET_OK; diff --git a/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc b/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc index bb622da414..f4d8b9a660 100644 --- a/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc @@ -149,13 +149,13 @@ const AnfNodePtr BatchMatMulFusion::Process(const FuncGraphPtr &func_graph, cons for (size_t i = 1; i < stack_cnode->inputs().size(); i++) { auto fullconnect_node2 = stack_cnode->input(i)->cast(); auto fc_prim = GetValueNode>(fullconnect_node2->input(0)); - auto fc_input_quantParams = fc_prim->GetInputQuantParams(); + auto fc_input_quantParams = fc_prim->input_quant_params(); if (fc_input_quantParams.size() > 1 && !fc_input_quantParams[1].empty()) { jointed_quant_params.push_back(fc_input_quantParams[1][0]); } } auto fc_prim = GetValueNode>(fullconnect_cnode->input(0)); - auto rmatmul_quant_params = fc_prim->GetInputQuantParams(); + auto rmatmul_quant_params = fc_prim->input_quant_params(); rmatmul_quant_params.pop_back(); rmatmul_quant_params.pop_back(); // no bias quantParams @@ -164,8 +164,8 @@ const AnfNodePtr BatchMatMulFusion::Process(const FuncGraphPtr &func_graph, cons MS_LOG(ERROR) << "matmul_cvalue is nullptr."; return nullptr; } - matmul_cvalue->SetInputQuantParams(rmatmul_quant_params); - matmul_cvalue->SetOutputQuantParams(fc_prim->GetOutputQuantParams()); + matmul_cvalue->set_input_quant_params(rmatmul_quant_params); + matmul_cvalue->set_output_quant_params(fc_prim->output_quant_params()); auto matmul_value_node = NewValueNode(std::shared_ptr(matmul_cvalue)); std::vector matmul_inputs = {matmul_value_node, left_matmul_input}; @@ -177,11 +177,11 @@ const AnfNodePtr BatchMatMulFusion::Process(const FuncGraphPtr &func_graph, cons return node; } auto prim = GetValueNode>(matmul_value_node); - if (prim->GetPrimitiveT()->value.AsMatMul() == nullptr) { - MS_LOG(ERROR) << "prim->GetPrimitiveT()->value.AsMatMul() is nullptr."; + if (prim->primitiveT()->value.AsMatMul() == nullptr) { + MS_LOG(ERROR) << "prim->primitiveT()->value.AsMatMul() is nullptr."; return nullptr; } - prim->GetPrimitiveT()->value.AsMatMul()->transposeB = true; + prim->primitiveT()->value.AsMatMul()->transposeB = true; matmul_inputs.push_back(rmatmul_paramter); } else { auto right_reshape_cnode = right_reshape_node->cast(); diff --git a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc index 45d804543d..45c148fb1f 100644 --- a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc @@ -88,7 +88,7 @@ ParameterPtr CreateNewParamter(const FuncGraphPtr &func_graph, Tensor *tensor) { MS_ASSERT(param_value != nullptr); param_value->set_tensor_shape(shape); param_value->set_tensor_type(type_id); - param_value->set_format(tensor->GetFormat()); + param_value->set_format(tensor->format()); if (tensor->MutableData() != nullptr) { auto size = tensor->Size(); auto tensor_data = new (std::nothrow) uint8_t[size]; @@ -209,7 +209,7 @@ const AnfNodePtr ConstFoldPass::Process(const FuncGraphPtr &func_graph, const An FreeTensors(&input_tensors, &output_tensors); return nullptr; } - auto inputQuantParams = lite_primitive->GetInputQuantParams(); + auto inputQuantParams = lite_primitive->input_quant_params(); for (size_t m = 0; m < inputQuantParams.size(); m++) { for (auto inputQuantParam : inputQuantParams[m]) { lite::QuantArg quant_arg{}; @@ -218,7 +218,7 @@ const AnfNodePtr ConstFoldPass::Process(const FuncGraphPtr &func_graph, const An input_tensors[m]->AddQuantParam(quant_arg); } } - auto outputQuantParams = lite_primitive->GetOutputQuantParams(); + auto outputQuantParams = lite_primitive->output_quant_params(); for (size_t m = 0; m < outputQuantParams.size(); m++) { for (auto outputQuantParam : outputQuantParams[m]) { lite::QuantArg quant_arg{}; @@ -231,7 +231,7 @@ const AnfNodePtr ConstFoldPass::Process(const FuncGraphPtr &func_graph, const An // but for the time being, we only transpose the tensor with 0/1/2/3D. // Others should be added in future. for (auto &input_tensor : input_tensors) { - input_tensor->SetFormat(schema::Format::Format_NHWC); + input_tensor->set_format(schema::Format::Format_NHWC); if (input_tensor->shape().size() == 4) { MS_LOG(INFO) << "init input_tensor format to nhwc"; } diff --git a/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc b/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc index 3f76c053ea..8c3a8a5bec 100644 --- a/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/clip_convert_activation_pass.cc @@ -47,7 +47,7 @@ bool ClipConvertActivationPass::Run(const FuncGraphPtr &graph) { auto primitive_c = GetValueNode>(clip_cnode->input(0)); MS_ASSERT(primitive_c != nullptr); - auto primT = primitive_c->GetPrimitiveT(); + auto primT = primitive_c->primitiveT(); if (primT == nullptr || primT->value.AsClip() == nullptr) { MS_LOG(ERROR) << "primT is null"; return false; diff --git a/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc b/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc index 67f277215a..2d4bf3c82b 100644 --- a/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/unused_transpose_node_remove_pass.cc @@ -51,7 +51,7 @@ bool RemoveUnusedTransposeOpPass::Run(const FuncGraphPtr &func_graph) { MS_LOG(ERROR) << "Transpose node of onnx need to removed which has not primitiveC"; return RET_ERROR; } - auto primT = primPtr->GetPrimitiveT(); + auto primT = primPtr->primitiveT(); if (primT == nullptr) { MS_LOG(ERROR) << "Transpose node of onnx need to removed which has not primitiveC"; return RET_ERROR; @@ -74,7 +74,7 @@ bool RemoveUnusedTransposeOpPass::Run(const FuncGraphPtr &func_graph) { MS_LOG(ERROR) << "Transpose node of onnx need to removed which has not primitiveC"; return RET_ERROR; } - auto primT = primPtr->GetPrimitiveT(); + auto primT = primPtr->primitiveT(); if (primT == nullptr) { MS_LOG(ERROR) << "Transpose node of onnx need to removed which has not primitiveT"; return RET_ERROR;