From bd7ecf9a1a879173d5f4641d22385040ddbfb1e1 Mon Sep 17 00:00:00 2001 From: yefeng Date: Fri, 20 Nov 2020 13:06:49 +0800 Subject: [PATCH] clean_code_8 --- mindspore/lite/src/common/file_utils.cc | 22 +++++----- mindspore/lite/src/common/log_adapter.cc | 4 +- mindspore/lite/src/common/utils.cc | 12 +++--- mindspore/lite/src/common/utils.h | 4 +- mindspore/lite/src/kernel_registry.cc | 2 +- mindspore/lite/src/lite_kernel.cc | 12 +++--- mindspore/lite/src/lite_kernel.h | 16 +++---- mindspore/lite/src/lite_session.cc | 2 +- mindspore/lite/src/model_common.h | 4 +- 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/dropout.cc | 6 +-- mindspore/lite/src/ops/dropout_grad.cc | 4 +- 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 | 2 +- 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/maximum_grad.cc | 2 +- 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 | 4 +- .../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 +- .../arm/fp32/convolution_depthwise_fp32.cc | 2 +- .../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/fused_batchnorm_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 +- .../runtime/kernel/arm/fp32_grad/bn_grad.cc | 8 ++-- .../kernel/arm/fp32_grad/convolution.cc | 8 ++-- .../arm/fp32_grad/convolution_grad_filter.cc | 8 ++-- .../arm/fp32_grad/convolution_grad_input.cc | 8 ++-- .../fp32_grad/deconvolution_grad_filter.cc | 8 ++-- .../softmax_cross_entropy_with_logits.cc | 4 +- .../kernel/arm/fp32_grad/softmax_grad.cc | 4 +- ...parse_softmax_cross_entropy_with_logits.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 | 5 +-- .../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 +++--- .../src/runtime/kernel/arm/int8/tanh_int8.cc | 8 ++-- .../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 | 4 +- mindspore/lite/src/tensor.cc | 30 ++++++------- mindspore/lite/src/tensor.h | 10 ++--- mindspore/lite/src/train/train_session.cc | 12 +++--- .../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/fp32_grad/bn_grad_fp32_test.cc | 6 +-- .../fp32_grad/convolution_grad_fp32_tests.cc | 18 ++++---- .../deconvolution_grad_fp32_tests.cc | 12 +++--- .../softmax_crossentropy_fp32_tests.cc | 2 +- .../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 | 30 ++++++------- .../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 +- .../tools/optimizer/graph/infershape_pass.cc | 6 +-- .../optimizer/graph/slice_prepose_pass.cc | 12 +++--- .../unused_transpose_node_remove_pass.cc | 4 +- 228 files changed, 727 insertions(+), 726 deletions(-) diff --git a/mindspore/lite/src/common/file_utils.cc b/mindspore/lite/src/common/file_utils.cc index 8b25f0dbd6..7991888058 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) { - MS_LOG(ERROR) << "new resolvedPath failed"; + auto resolved_path = std::make_unique(PATH_MAX); + if (resolved_path == nullptr) { + MS_LOG(ERROR) << "new resolved_path 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..7357289ae9 100644 --- a/mindspore/lite/src/common/utils.cc +++ b/mindspore/lite/src/common/utils.cc @@ -48,11 +48,11 @@ 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 &subStr, RemoveSubStrMode mode) { std::string result = from; if (mode == PREFIX) { if (from.substr(0, subStr.length()) == subStr) { @@ -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 {}; } @@ -104,7 +104,7 @@ std::vector Tokenize(const std::string &src, const std::string &del break; } size_t delimiter = src.find_first_of(delimiters, nonDelimiter); - if (delimiter == std::string::npos || (maxTokenNum.IsSome() && tokens.size() == maxTokenNum.Get() - 1)) { + if (delimiter == std::string::npos || (max_token_num.IsSome() && tokens.size() == max_token_num.Get() - 1)) { tokens.push_back(src.substr(nonDelimiter)); break; } diff --git a/mindspore/lite/src/common/utils.h b/mindspore/lite/src/common/utils.h index f5fd8a94f7..e8682f48d1 100644 --- a/mindspore/lite/src/common/utils.h +++ b/mindspore/lite/src/common/utils.h @@ -148,10 +148,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 &subStr, 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/lite_kernel.cc b/mindspore/lite/src/lite_kernel.cc index a0805dd2cd..f7d3bd87b1 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_kernel({}); + kernel->set_out_kernel({}); // 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 1e2877b514..5811a2ee88 100644 --- a/mindspore/lite/src/lite_kernel.h +++ b/mindspore/lite/src/lite_kernel.h @@ -109,9 +109,9 @@ class LiteKernel { virtual bool IsEval() const { return !this->train_mode_; } - virtual void SetTrainable(bool trainable = true) { this->trainable_ = trainable; } + virtual void set_trainable(bool trainable = true) { this->trainable_ = trainable; } - virtual bool IsTrainable() const { return this->trainable_; } + virtual bool is_trainable() const { return this->trainable_; } void set_name(const std::string &name) { this->name_ = name; } @@ -146,9 +146,9 @@ class LiteKernel { } } - void SetInKernel(const std::vector &kernel) { this->in_kernels_ = kernel; } + void set_in_kernel(const std::vector &kernel) { this->in_kernels_ = kernel; } - void SetOutKernel(const std::vector &kernel) { this->out_kernels_ = kernel; } + void set_out_kernel(const std::vector &kernel) { this->out_kernels_ = kernel; } const std::vector &in_kernels() const { return this->in_kernels_; } @@ -165,18 +165,18 @@ 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_; } + 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 3a90d24441..c58c64c722 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.h b/mindspore/lite/src/model_common.h index 866254cd99..ceebf75a90 100644 --- a/mindspore/lite/src/model_common.h +++ b/mindspore/lite/src/model_common.h @@ -32,7 +32,7 @@ namespace mindspore::lite { int ConvertSubGraph(const schema::SubGraph &sub_graph, Model *model); template -bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) { +bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = SCHEMA_CUR) { MS_ASSERT(model != nullptr); for (size_t i = 0; i < meta_graph.nodes()->size(); ++i) { auto *node = new (std::nothrow) Model::Node(); @@ -53,7 +53,7 @@ bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) { delete node; return false; } - node->primitive_->SetQuantType(static_cast(c_node->quantType())); + node->primitive_->set_quant_type(static_cast(c_node->quantType())); node->name_ = c_node->name()->c_str(); node->node_type_ = static_cast(c_node->nodeType()); auto count = c_node->inputIndex()->size(); diff --git a/mindspore/lite/src/ops/adam.cc b/mindspore/lite/src/ops/adam.cc index 45c28be1a1..ed2cc49c9f 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 35ae4903e8..eec0d79df7 100644 --- a/mindspore/lite/src/ops/bias_grad.cc +++ b/mindspore/lite/src/ops/bias_grad.cc @@ -111,7 +111,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 c054911b51..17916da72a 100644 --- a/mindspore/lite/src/ops/bn_grad.cc +++ b/mindspore/lite/src/ops/bn_grad.cc @@ -106,9 +106,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 8ee75c14ba..5403bfa03a 100644 --- a/mindspore/lite/src/ops/cast.cc +++ b/mindspore/lite/src/ops/cast.cc @@ -93,10 +93,10 @@ 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()); 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 aa739c61e7..457f8de8e6 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 cacf29ae35..83babc623c 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 098b367fa6..6090b6f318 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 b32b540172..6556d3b86f 100644 --- a/mindspore/lite/src/ops/conv2d_grad_filter.cc +++ b/mindspore/lite/src/ops/conv2d_grad_filter.cc @@ -138,8 +138,8 @@ int Conv2DGradFilter::UnPackAttr(const Primitive &prim, const std::vectoractivationType = schema::ActivationType_NO_ACTIVATION; } - if (inputs.size() >= kAnfPopulaterThree) { - auto filter_shape = inputs[kAnfPopulaterTwo]; + if (inputs.size() >= kAnfPopulaterInputNumThree) { + auto filter_shape = inputs[kAnfPopulaterInputNumTwo]; MS_ASSERT(filter_shape != nullptr); if (filter_shape->isa()) { auto valueNode = filter_shape->cast(); @@ -239,7 +239,7 @@ int Conv2DGradFilter::InferShape(std::vector inputs, std::vectorset_shape(GetFilterShape()); 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 7c6dd6e520..0a8501dc47 100644 --- a/mindspore/lite/src/ops/conv2d_grad_input.cc +++ b/mindspore/lite/src/ops/conv2d_grad_input.cc @@ -140,8 +140,8 @@ int Conv2DGradInput::UnPackAttr(const Primitive &prim, const std::vectoractivationType = schema::ActivationType_NO_ACTIVATION; } - if (inputs.size() >= kAnfPopulaterThree) { - auto input_shape = inputs[kAnfPopulaterTwo]; + if (inputs.size() >= kAnfPopulaterInputNumThree) { + auto input_shape = inputs[kAnfPopulaterInputNumTwo]; MS_ASSERT(input_shape != nullptr); if (input_shape->isa()) { auto valueNode = input_shape->cast(); @@ -239,7 +239,7 @@ int Conv2DGradInput::InferShape(std::vector inputs, std::vectorset_shape(GetInputShape()); 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 41300e6b33..109305009d 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 4bc0765bb1..6e5f920a3a 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::vectorchannelMultiplier = 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 1eae48be53..c96078747f 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/dropout.cc b/mindspore/lite/src/ops/dropout.cc index dd74b24506..32c6baa7a8 100644 --- a/mindspore/lite/src/ops/dropout.cc +++ b/mindspore/lite/src/ops/dropout.cc @@ -83,19 +83,19 @@ int Dropout::InferShape(std::vector inputs_, std::vector out MS_ASSERT(input != nullptr); auto output0 = outputs_.front(); MS_ASSERT(output0 != nullptr); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } output0->set_shape(input->shape()); output0->set_data_type(input->data_type()); - output0->SetFormat(input->GetFormat()); + output0->set_format(input->format()); if (outputs_.size() > 1) { auto output1 = outputs_[1]; MS_ASSERT(output1 != nullptr); output1->set_shape(input->shape()); output1->set_data_type(input->data_type()); - output1->SetFormat(input->GetFormat()); + output1->set_format(input->format()); } return RET_OK; diff --git a/mindspore/lite/src/ops/dropout_grad.cc b/mindspore/lite/src/ops/dropout_grad.cc index 99b348f005..e459dc65b3 100644 --- a/mindspore/lite/src/ops/dropout_grad.cc +++ b/mindspore/lite/src/ops/dropout_grad.cc @@ -86,12 +86,12 @@ int DropoutGrad::InferShape(std::vector inputs_, std::vector MS_ASSERT(input != nullptr); auto output = outputs_.front(); MS_ASSERT(output != nullptr); - if (!GetInferFlag()) { + if (!infer_flag()) { return RET_OK; } output->set_shape(input->shape()); output->set_data_type(input->data_type()); - output->SetFormat(input->GetFormat()); + output->set_format(input->format()); return RET_OK; } 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 d15438ceef..35d5840974 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 5777a81ba0..99b97c3205 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 673d89a8cd..561f1286f3 100644 --- a/mindspore/lite/src/ops/group_conv2d_grad_input.cc +++ b/mindspore/lite/src/ops/group_conv2d_grad_input.cc @@ -169,7 +169,7 @@ int GroupConv2DGradInput::InferShape(std::vector inputs, std::vectorset_shape(GetInputShape()); 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 9b4c2a622c..d479bdddb0 100644 --- a/mindspore/lite/src/ops/hashtable_lookup.cc +++ b/mindspore/lite/src/ops/hashtable_lookup.cc @@ -54,10 +54,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 c9bc0e54b6..5ab54d9be0 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 b0f4d7771c..25e7fc7311 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 40cbdd351e..3ffbeaa654 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/maximum_grad.cc b/mindspore/lite/src/ops/maximum_grad.cc index 9644957f55..6a0cc672a1 100644 --- a/mindspore/lite/src/ops/maximum_grad.cc +++ b/mindspore/lite/src/ops/maximum_grad.cc @@ -92,7 +92,7 @@ int MaximumGrad::InferShape(std::vector inputs_, std::vector MS_ASSERT(x2 != nullptr); MS_ASSERT(dx1 != nullptr); MS_ASSERT(dx2 != nullptr); - if (!GetInferFlag()) { + 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 e979897647..b3bd9c9672 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 e5ea31cc1d..30a9f54b31 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 9a2dd6a853..c871c5effd 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 5f44f2d239..f2c288ecfa 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 8d8fbc6d6a..1a0b076404 100644 --- a/mindspore/lite/src/ops/primitive_c.cc +++ b/mindspore/lite/src/ops/primitive_c.cc @@ -342,24 +342,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; } @@ -396,16 +397,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; @@ -463,7 +464,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"; @@ -956,8 +957,8 @@ PrimitiveC *PrimitiveC::Create(mindspore::schema::PrimitiveT *primitive) { } #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 { @@ -970,18 +971,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 30f54b4bd7..89e5f0c007 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}, @@ -75,7 +75,7 @@ class PrimitiveC : public mindspore::Primitive { int Type() const; - schema::PrimitiveT *GetPrimitiveT() const; + schema::PrimitiveT *primitiveT() const; void ClearPrimitiveT(); @@ -90,13 +90,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(); @@ -106,21 +106,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()); } @@ -162,16 +162,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 ae54698c2b..0be455d5d0 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 289853f962..e70d087280 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() == this->GetSrcT()); 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 7087068d07..0f7fd8b4ee 100644 --- a/mindspore/lite/src/ops/range.cc +++ b/mindspore/lite/src/ops/range.cc @@ -65,8 +65,8 @@ int Range::InferShape(std::vector inputs_, std::vector outpu 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/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 786485178e..cc92c8a660 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 bd2a429a64..6cbdb7bdb5 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 9f5e21df97..bab8d9dd4b 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 8fd6c6c119..7b306c9db9 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 d079f9ed9c..d89521f5bb 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 b68c0309f1..205db3e855 100644 --- a/mindspore/lite/src/ops/space_to_batch.cc +++ b/mindspore/lite/src/ops/space_to_batch.cc @@ -90,13 +90,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 50e0976df6..a64e9b1160 100644 --- a/mindspore/lite/src/ops/space_to_batch_nd.cc +++ b/mindspore/lite/src/ops/space_to_batch_nd.cc @@ -92,13 +92,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 2a76d18788..6c9a4cd340 100644 --- a/mindspore/lite/src/ops/sparse_to_dense.cc +++ b/mindspore/lite/src/ops/sparse_to_dense.cc @@ -61,9 +61,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 0daf210f1c..2b890a1472 100644 --- a/mindspore/lite/src/ops/split.cc +++ b/mindspore/lite/src/ops/split.cc @@ -120,9 +120,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(); @@ -148,7 +148,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 faef4bf90e..7d73e13b63 100644 --- a/mindspore/lite/src/ops/squeeze.cc +++ b/mindspore/lite/src/ops/squeeze.cc @@ -103,8 +103,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 b5075f3549..e4d159b0e9 100644 --- a/mindspore/lite/src/ops/strided_slice.cc +++ b/mindspore/lite/src/ops/strided_slice.cc @@ -78,17 +78,17 @@ int StridedSlice::UnPackAttr(const Primitive &prim, const std::vectorellipsisMask = CastToInt(prim.GetAttr("ellipsis_mask"), false).front(); attr->newAxisMask = CastToInt(prim.GetAttr("new_axis_mask"), false).front(); attr->shrinkAxisMask = CastToInt(prim.GetAttr("shrink_axis_mask"), false).front(); - 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; @@ -343,10 +343,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(); in_shape_.clear(); begins_.clear(); diff --git a/mindspore/lite/src/ops/tile.cc b/mindspore/lite/src/ops/tile.cc index 893877e95c..412e2565d5 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 = CastToInt(prim.GetAttr("dims"), true); } - 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 a72731574e..07e71a31de 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; } auto out_shape = input->shape(); diff --git a/mindspore/lite/src/ops/transpose.cc b/mindspore/lite/src/ops/transpose.cc index f11b3703b8..c895377e10 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 || inputs_.size() == kDoubleNum); 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 5394472200..67c8242d10 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..f1ff0aa761 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; + lockFlag_ = ctx.lockFlag; + shiftFactor_ = ctx.shiftFactor; } void DefaultAllocator::Lock() { - if (lockFlag) { - lock.lock(); + if (lockFlag_) { + lock_.lock(); } } void DefaultAllocator::UnLock() { - if (lockFlag) { - lock.unlock(); + if (lockFlag_) { + 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 = freeList_.lower_bound(size); + if (iter != freeList_.end() && (iter->second->size >= size) && (iter->second->size < (size << shiftFactor_))) { auto membuf = iter->second; - freeList.erase(iter); - allocatedList[membuf->buf] = membuf; + freeList_.erase(iter); + allocatedList_[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(); + allocatedList_[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 = allocatedList_.find(buf); + if (iter != allocatedList_.end()) { auto membuf = iter->second; - allocatedList.erase(iter); - freeList.insert(std::make_pair(membuf->size, membuf)); + allocatedList_.erase(iter); + freeList_.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 = allocatedList_.begin(); it != allocatedList_.end(); it++) { auto membuf = it->second; totalSize += membuf->size; } - for (auto it = freeList.begin(); it != freeList.end(); it++) { + for (auto it = freeList_.begin(); it != freeList_.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 = allocatedList_.begin(); it != allocatedList_.end(); it++) { free(it->second); } - allocatedList.clear(); + allocatedList_.clear(); - for (auto it = freeList.begin(); it != freeList.end(); it++) { + for (auto it = freeList_.begin(); it != freeList_.end(); it++) { free(it->second); } - freeList.clear(); + freeList_.clear(); UnLock(); } } // namespace mindspore::lite diff --git a/mindspore/lite/src/runtime/allocator.h b/mindspore/lite/src/runtime/allocator.h index fe16bfed8c..94c3ef6709 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 allocatedList_; + std::multimap freeList_; // 6 is empirical value - int shiftFactor = 6; - bool lockFlag = false; + int shiftFactor_ = 6; + bool lockFlag_ = 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 7953b1ce06..9b46736258 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 4d0f8eea9b..c474167d68 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->data_c()); MS_ASSERT(anchor_int8 != nullptr); auto anchor_fp32 = new (std::nothrow) float[anchor_tensor->ElementsNum()]; @@ -60,7 +60,7 @@ int DetectionPostProcessBaseCPUKernel::Init() { anchor_tensor->ElementsNum()); params_->anchors_ = anchor_fp32; } else if (anchor_tensor->data_type() == kNumberTypeUInt8) { - auto quant_param = anchor_tensor->GetQuantParams().front(); + auto quant_param = anchor_tensor->quant_params().front(); auto anchor_uint8 = reinterpret_cast(anchor_tensor->data_c()); MS_ASSERT(anchor_uint8 != nullptr); auto anchor_fp32 = new (std::nothrow) float[anchor_tensor->ElementsNum()]; 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 4be43df6fb..cc9d4990c2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc +++ b/mindspore/lite/src/runtime/kernel/arm/base/pooling_base.cc @@ -46,9 +46,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 bbfd9f9409..5acc136ae1 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 @@ -104,13 +104,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, @@ -129,11 +128,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 4a07ce9515..9c71a30746 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc @@ -100,10 +100,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 b0f318769a..130841ede9 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 @@ -140,8 +140,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 1935405e57..3f74a3cf0b 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/convolution_fp16.cc @@ -297,7 +297,7 @@ lite::Tensor *CreateOutputTensor(std::vector out_shape, const std::vectorset_data_type(outputs.at(index)->data_type()); - out_tensor->SetFormat(outputs.at(index)->GetFormat()); + out_tensor->set_format(outputs.at(index)->format()); if (infered_flag) { out_tensor->set_shape(out_shape); auto ret = out_tensor->MallocData(); @@ -317,7 +317,7 @@ kernel::LiteKernel *CpuGroupConvFp16KernelCreator(const std::vectorGetInferFlag()); + bool infered_flag = (primitive != nullptr && primitive->infer_flag()); auto conv_param = reinterpret_cast(op_parameter); // update new shape info for each sub kernel @@ -418,8 +418,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) { @@ -434,7 +434,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 678d0cf9c1..44c97598f3 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 @@ -209,8 +209,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 20d9babe81..5ed33e0d18 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 9dfae0ffae..a27d7dabfe 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc @@ -238,8 +238,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 8db10a93ef..7fdfd713cc 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 3de4d792f9..46edd49454 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc @@ -333,8 +333,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 0879b04edf..a318d0ceb2 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; if (inverse_) { ret = DoDequantizeInt8ToFp16(int8_ptr_ + thread_offset, float16_ptr_ + thread_offset, quant_arg.scale, 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_depthwise_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32.cc index ae0f675e99..4368e30ef6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32.cc @@ -138,7 +138,7 @@ kernel::LiteKernel *CpuConvDwFp32KernelCreator(const std::vector auto conv_param = reinterpret_cast(opParameter); kernel::LiteKernel *kernel = nullptr; - 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(); 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 195c69e90e..3418c404a6 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/convolution_fp32.cc @@ -256,7 +256,7 @@ lite::Tensor *CreateOutputTensorFp32(std::vector out_shape, const std::vect return nullptr; } out_tensor->set_data_type(outputs.at(index)->data_type()); - out_tensor->SetFormat(outputs.at(index)->GetFormat()); + out_tensor->set_format(outputs.at(index)->format()); if (infered_flag) { out_tensor->set_shape(out_shape); auto ret = out_tensor->MallocData(); @@ -292,7 +292,7 @@ kernel::LiteKernel *CpuGroupConvFp32KernelCreator(const std::vectorGetInferFlag(); + bool infered_flag = primitive != nullptr && primitive->infer_flag(); auto conv_param = reinterpret_cast(op_parameter); std::vector in_shape; @@ -396,7 +396,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(); @@ -410,8 +410,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 c317b1118b..5af04ba8e7 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 @@ -197,8 +197,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 d67289c1e1..0f027fe238 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc @@ -235,8 +235,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/fused_batchnorm_fp32.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/fused_batchnorm_fp32.cc index e55ab6efb2..ba5d28b6a5 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/fused_batchnorm_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/fused_batchnorm_fp32.cc @@ -68,7 +68,7 @@ int FusedBatchnormCPUKernel::InitConstTensor() { int FusedBatchnormCPUKernel::Run() { auto param = reinterpret_cast(op_parameter_); - if (IsTrain() && IsTrainable() && in_tensors_.size() >= 5) { + if (IsTrain() && is_trainable() && in_tensors_.size() >= 5) { float *in = static_cast(in_tensors_[0]->MutableData()); float *scale = static_cast(in_tensors_[1]->MutableData()); float *offset = static_cast(in_tensors_[2]->MutableData()); 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 b947998ca4..cf250a950e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc @@ -395,8 +395,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 135486f0ab..40e420d2a8 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 d055b80c91..3d05ea3ca0 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/fp32_grad/bn_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc index 12c8002b70..577a97205f 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/bn_grad.cc @@ -35,7 +35,7 @@ namespace mindspore::kernel { int BNGradCPUKernel::Init() { auto *input_x = in_tensors_.at(1); int channels = input_x->shape().at(kNHWC_C); - SetWorkspaceSize(2 * channels * sizeof(float)); + set_workspace_size(2 * channels * sizeof(float)); return RET_OK; } @@ -60,9 +60,9 @@ int BNGradCPUKernel::Execute(int task_id) { size_t spatial = input_x->Height() * input_x->Width(); float eps = bn_param->epsilon_; - float *workspace = static_cast(GetWorkspace()); - std::fill(workspace, workspace + GetWorkspaceSize() / sizeof(*workspace), 0.f); - float *dxhat_sum = workspace; + float *workspace_temp = static_cast(workspace()); + std::fill(workspace_temp, workspace_temp + workspace_size() / sizeof(*workspace_temp), 0.f); + float *dxhat_sum = workspace_temp; float *dxhathat_sum = dxhat_sum + channels; float *x = reinterpret_cast(input_x->MutableData()); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc index af2f29b4ef..8f9623d683 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution.cc @@ -56,7 +56,7 @@ int ConvolutionTrainCPUKernel::Init() { const int k = conv_param_->kernel_h_ * conv_param_->kernel_w_ * conv_param_->input_channel_ / conv_param_->group_; ws_size = chunk * k; int mat_alloc = MatSizeTotal(chunk, n, k, 0); - SetWorkspaceSize((ws_size + mat_alloc) * sizeof(float)); + set_workspace_size((ws_size + mat_alloc) * sizeof(float)); return RET_OK; } @@ -86,13 +86,13 @@ int ConvolutionTrainCPUKernel::Execute(int task_id) { const int m = out_h * out_w; const int n = out_ch / groups; const int k = k_h * k_w * in_ch / groups; - float *workspace = static_cast(GetWorkspace()); - float *mat_workspace = workspace + ws_size; + float *workspace_temp = static_cast(workspace()); + float *mat_workspace = workspace_temp + ws_size; for (int i = 0; i < batch; ++i) { for (int j = 0; j < groups; ++j) { for (int ci = 0; ci < m; ci += chunk) { int real_chunk = MSMIN(m - ci, chunk); - float *mat_a = workspace; + float *mat_a = workspace_temp; const float *mat_b = w_addr + j * nweights / groups; float *mat_c = y_addr + (i * groups) * n * m + j * (out_ch / groups) + ci * out_ch; float *im = x_addr + (i * groups) * (in_ch / groups) * in_h * in_w + j * (in_ch / groups); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc index 5c73bbfe63..31de63f2c2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_filter.cc @@ -56,7 +56,7 @@ int ConvolutionGradFilterCPUKernel::Init() { int n = conv_param->kernel_h_ * conv_param->kernel_w_ * conv_param->input_channel_ / conv_param->group_; int k = conv_param->output_channel_ / conv_param->group_; size_t mat_alloc = MatSizeTotal(k, n, chunk, n); - SetWorkspaceSize((ws_size + mat_alloc) * sizeof(float)); + set_workspace_size((ws_size + mat_alloc) * sizeof(float)); return RET_OK; } @@ -89,8 +89,8 @@ int ConvolutionGradFilterCPUKernel::Execute(int task_id) { int n = k_h * k_w * in_ch / groups; int k = out_ch / groups; - float *workspace = reinterpret_cast(GetWorkspace()); - float *mat_workspace = workspace + ws_size; + float *workspace_temp = reinterpret_cast(workspace()); + float *mat_workspace = workspace_temp + ws_size; // zero out pointer memset(dw_addr, 0, out_dw->Size()); for (i = 0; i < batch; ++i) { @@ -98,7 +98,7 @@ int ConvolutionGradFilterCPUKernel::Execute(int task_id) { for (int ci = 0; ci < m; ci += chunk) { int real_chunk = MSMIN(m - ci, chunk); float *mat_a = dy_addr + (i * groups) * m * k + j * (out_ch / groups) + ci * out_ch; - float *mat_b = workspace; + float *mat_b = workspace_temp; float *mat_c = dw_addr + j * nweights / groups; float *im = x_addr + (i * in_ch * in_h * in_w) + j * (in_ch / groups); memset(mat_b, 0, n * real_chunk * sizeof(float)); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_input.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_input.cc index 72082b5066..b770ea1b91 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_input.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/convolution_grad_input.cc @@ -58,7 +58,7 @@ int ConvolutionGradInputCPUKernel::Init() { size_t mat_alloc = MatSizeTotal(chunk, n, k, 0); - SetWorkspaceSize((ws_size + mat_alloc) * sizeof(float)); + set_workspace_size((ws_size + mat_alloc) * sizeof(float)); return RET_OK; } @@ -90,8 +90,8 @@ int ConvolutionGradInputCPUKernel::Execute(int task_id) { int m = out_h * out_w; int n = k_w * k_h * in_ch / groups; int k = out_ch / groups; - float *workspace = reinterpret_cast(GetWorkspace()); - float *mat_workspace = workspace + ws_size; + float *workspace_temp = reinterpret_cast(workspace()); + float *mat_workspace = workspace_temp + ws_size; memset(dx_addr, 0, sizeof(float) * batch * in_ch * in_h * in_w); for (i = 0; i < batch; ++i) { for (j = 0; j < groups; ++j) { @@ -110,7 +110,7 @@ int ConvolutionGradInputCPUKernel::Execute(int task_id) { } int real_chunk = MSMIN(m - ci, chunk); float *mat_a = dy_addr + (i * groups) * m * k + j * (out_ch / groups) + ci * out_ch; - float *mat_c = workspace; + float *mat_c = workspace_temp; GemmMatmulPlus(0, 0, real_chunk, n, k, 1, mat_a, out_ch, mat_b, n, 0, mat_c, n, mat_workspace, &gcb); rolling_col2im_hwc(mat_c, dx_addr + (i * groups) * (in_ch / groups) * in_h * in_w + j * (in_ch / groups), conv_param, real_chunk, ci); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc index 34e425d10c..f2523ee03e 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_filter.cc @@ -57,7 +57,7 @@ int DeConvolutionGradFilterCPUKernel::Init() { int n = conv_param->kernel_h_ * conv_param->kernel_w_ * conv_param->output_channel_ / conv_param->group_; size_t mat_alloc = MatSizeTotal(n, m, chunk * conv_param->input_w_, conv_param->input_channel_); - SetWorkspaceSize((ws_size + mat_alloc) * sizeof(float)); + set_workspace_size((ws_size + mat_alloc) * sizeof(float)); return RET_OK; } @@ -89,8 +89,8 @@ int DeConvolutionGradFilterCPUKernel::Execute(int task_id) { const int m = in_ch / groups; const int n = k_h * k_w * out_ch / groups; - float *workspace = reinterpret_cast(GetWorkspace()); - float *mat_workspace = workspace + ws_size; + float *workspace_temp = reinterpret_cast(workspace()); + float *mat_workspace = workspace_temp + ws_size; // zero out pointer memset(dw_addr, 0, out_dw->Size()); for (i = 0; i < batch; ++i) { @@ -98,7 +98,7 @@ int DeConvolutionGradFilterCPUKernel::Execute(int task_id) { for (int ci = 0; ci < in_h; ci += chunk) { int real_chunk = MSMIN(in_h - ci, chunk); float *mat_a = x_addr + (i * (in_ch * in_h * in_w) + j * (in_ch / groups)) + ci * in_w * in_ch; - float *mat_b = workspace; + float *mat_b = workspace_temp; float *mat_c = dw_addr + j * m; float *im = dy_addr + (i * (out_h * out_w * out_ch) + j * (out_ch / groups)); rolling_im2row_hwc(im, mat_b, conv_param, real_chunk, ci); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc index 5b4a5be4a2..cc31dfbce4 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc @@ -70,7 +70,7 @@ int SoftmaxCrossEntropyWithLogitsCPUKernel::Execute(int task_id) { MS_ASSERT(out != nullptr); MS_ASSERT(labels != nullptr); MS_ASSERT(ins != nullptr); - float *losses_ = static_cast(GetWorkspace()); + float *losses_ = static_cast(workspace()); float *sum_data_ = losses_ + data_size; std::fill(losses_, losses_ + data_size, 0); std::fill(sum_data_, sum_data_ + sm_params_.input_shape_[0], 0); @@ -115,7 +115,7 @@ int SoftmaxCrossEntropyWithLogitsCPUKernel::Init() { } size_t data_size = in_tensors_.at(0)->ElementsNum(); - SetWorkspaceSize((data_size + dims[0]) * sizeof(float)); + set_workspace_size((data_size + dims[0]) * sizeof(float)); sm_params_.n_dim_ = 2; sm_params_.element_size_ = data_size; sm_params_.axis_ = 1; diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc index a4a03b04e0..32034315a2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc @@ -51,7 +51,7 @@ int SoftmaxGradCPUKernel::Init() { for (size_t i = axis + 1; i < in_dims; i++) { inner_size_ *= in_shape[i]; } - SetWorkspaceSize(inner_size_ * (1 + in_shape[axis]) * sizeof(float)); + set_workspace_size(inner_size_ * (1 + in_shape[axis]) * sizeof(float)); return RET_OK; } @@ -61,7 +61,7 @@ int SoftmaxGradCPUKernel::Execute(int task_id) { auto input_ptr = reinterpret_cast(in_tensors_.at(kInputIndex)->MutableData()); auto yt_ptr = reinterpret_cast(in_tensors_.at(1)->MutableData()); auto output_ptr = reinterpret_cast(out_tensors_.at(kOutputIndex)->MutableData()); - float *sum_data_ = static_cast(GetWorkspace()); + float *sum_data_ = static_cast(workspace()); float *sum_mul_ = sum_data_ + inner_size_; SoftmaxGrad(input_ptr, yt_ptr, output_ptr, sum_data_, sum_mul_, reinterpret_cast(op_parameter_)); diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sparse_softmax_cross_entropy_with_logits.cc b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sparse_softmax_cross_entropy_with_logits.cc index 2e18530207..f78bfc1ca3 100644 --- a/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sparse_softmax_cross_entropy_with_logits.cc +++ b/mindspore/lite/src/runtime/kernel/arm/fp32_grad/sparse_softmax_cross_entropy_with_logits.cc @@ -94,7 +94,7 @@ int SparseSoftmaxCrossEntropyWithLogitsCPUKernel::Execute(int task_id) { MS_ASSERT(labels != nullptr); MS_ASSERT(ins != nullptr); - float *losses_ = static_cast(GetWorkspace()); + float *losses_ = static_cast(workspace()); float *sum_data_ = losses_ + data_size; std::fill(losses_, losses_ + data_size, 0.f); std::fill(sum_data_, sum_data_ + sm_params_.input_shape_[0], 0.f); @@ -142,7 +142,7 @@ int SparseSoftmaxCrossEntropyWithLogitsCPUKernel::Init() { return RET_ERROR; } size_t data_size = in_tensors_.at(0)->ElementsNum(); - SetWorkspaceSize((data_size + dims[0]) * sizeof(float)); + set_workspace_size((data_size + dims[0]) * sizeof(float)); sm_params_.n_dim_ = 2; sm_params_.element_size_ = data_size; sm_params_.axis_ = 1; 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 84c31c38a3..27d532fe8c 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/add_int8.cc @@ -35,13 +35,13 @@ int QuantizedAddCPUKernel::Init() { auto *input1 = in_tensors_.at(1); auto *output = out_tensors_.at(0); - para_.in0_zp_ = input0->GetQuantParams().front().zeroPoint * -1; - para_.in1_zp_ = input1->GetQuantParams().front().zeroPoint * -1; - para_.out_zp_ = output->GetQuantParams().front().zeroPoint; + para_.in0_zp_ = input0->quant_params().front().zeroPoint * -1; + para_.in1_zp_ = input1->quant_params().front().zeroPoint * -1; + para_.out_zp_ = output->quant_params().front().zeroPoint; - const double in0_scale = input0->GetQuantParams().front().scale; - const double in1_scale = input1->GetQuantParams().front().scale; - const double out_scale = output->GetQuantParams().front().scale; + const double in0_scale = input0->quant_params().front().scale; + const double in1_scale = input1->quant_params().front().scale; + const double out_scale = output->quant_params().front().scale; para_.left_shift_ = 20; const double twice_max_input_scale = 2 * std::max(in0_scale, in1_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 d4622d3a6c..a618882b7e 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 6b3c550f7f..81ebec4f77 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,11 +171,10 @@ 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(); 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 3e0784f015..c396179670 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 0f5853ccf5..f51eff128e 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 a6ec32402c..4e996b3617 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 @@ -38,17 +38,17 @@ int LayerNormInt8CPUKernel::SetQuantArgs() { lite::Tensor *input = in_tensors_.at(0); lite::Tensor *output = out_tensors_.at(0); - quant_param_.in_zp_ = input->GetQuantParams().front().zeroPoint; - quant_param_.in_scale_ = input->GetQuantParams().front().scale; - quant_param_.out_zp_ = output->GetQuantParams().front().zeroPoint; - quant_param_.out_scale_ = output->GetQuantParams().front().scale; + quant_param_.in_zp_ = input->quant_params().front().zeroPoint; + quant_param_.in_scale_ = input->quant_params().front().scale; + quant_param_.out_zp_ = output->quant_params().front().zeroPoint; + quant_param_.out_scale_ = output->quant_params().front().scale; if (param_->elementwise_affine_) { lite::Tensor *gamma_tensor = in_tensors_.at(1); lite::Tensor *beta_tensor = in_tensors_.at(2); - double gamma_scale = gamma_tensor->GetQuantParams().front().scale; - int gamma_zp = gamma_tensor->GetQuantParams().front().zeroPoint; + double gamma_scale = gamma_tensor->quant_params().front().scale; + int gamma_zp = gamma_tensor->quant_params().front().zeroPoint; gamma_ptr_ = reinterpret_cast(malloc(gamma_tensor->ElementsNum() * sizeof(float))); if (gamma_ptr_ == nullptr) { MS_LOG(ERROR) << "malloc gamma_ptr_ failed"; 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 3243f678cb..0d35fc1376 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 63176af092..f7b24b4170 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 85110753d3..a5caa2dcf0 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/reduce_int8.cc @@ -227,10 +227,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 0096c6c533..3c8520f474 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 8c37c43920..55b19c6804 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc @@ -77,11 +77,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 6a9409a89c..1662c81099 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 18ec0c6943..f58ff57c86 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_) { DoSpaceToBatchPaddingNHWCInt8(input_ptr, output_ptr, param, quant_arg.zeroPoint); 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 b435b78943..e47df842fd 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_ == this->out_tensors_.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 8e83fbd97c..42f674e5a6 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(this->out_tensors_.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/tanh_int8.cc b/mindspore/lite/src/runtime/kernel/arm/int8/tanh_int8.cc index 4424bd4e80..2f3b8006f2 100644 --- a/mindspore/lite/src/runtime/kernel/arm/int8/tanh_int8.cc +++ b/mindspore/lite/src/runtime/kernel/arm/int8/tanh_int8.cc @@ -25,10 +25,10 @@ int TanhInt8CPUKernel::Init() { lite::Tensor *input = in_tensors_.at(0); lite::Tensor *output = out_tensors_.at(0); - tanh_quant_.in_scale_ = input->GetQuantParams().front().scale; - tanh_quant_.in_zp_ = input->GetQuantParams().front().zeroPoint; - tanh_quant_.out_scale_ = output->GetQuantParams().front().scale; - tanh_quant_.out_zp_ = output->GetQuantParams().front().zeroPoint; + tanh_quant_.in_scale_ = input->quant_params().front().scale; + tanh_quant_.in_zp_ = input->quant_params().front().zeroPoint; + tanh_quant_.out_scale_ = output->quant_params().front().scale; + tanh_quant_.out_zp_ = output->quant_params().front().zeroPoint; if (!InferShapeDone()) { return RET_OK; 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 15e1d32789..9c930b76d8 100644 --- a/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc +++ b/mindspore/lite/src/runtime/kernel/opencl/kernel/scale.cc @@ -74,7 +74,7 @@ int ScaleOpenCLKernel::InitWeights() { 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()); @@ -83,8 +83,8 @@ int ScaleOpenCLKernel::InitWeights() { << 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) { @@ -129,8 +129,8 @@ int ScaleOpenCLKernel::InitWeights() { 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 f0c9ea01f1..57dfc989b6 100644 --- a/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc +++ b/mindspore/lite/src/runtime/kernel/opencl/subgraph_opencl_kernel.cc @@ -51,10 +51,10 @@ int SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToNull( nullptr); if (mem_type == MemType::IMG) { jv->set_in_tensors(tensors); - jv->SetInKernel(kernels); + jv->set_in_kernel(kernels); } else { jv->set_out_tensors(tensors); - jv->SetOutKernel(kernels); + jv->set_out_kernel(kernels); } } } @@ -81,11 +81,11 @@ int SubGraphOpenCLKernel::ReplaceOutTensorAndKernelToConvert(const lite::Tensor tensors.emplace_back(new_tensor); } if (mem_type == MemType::IMG) { - iv->SetInKernel(kernels); + iv->set_in_kernel(kernels); iv->set_in_tensors(tensors); in_opencl_op->AddOutKernel(iv); } else { - iv->SetOutKernel(kernels); + iv->set_out_kernel(kernels); iv->set_out_tensors(tensors); in_convert_op->AddInKernel(iv); } @@ -118,11 +118,11 @@ int SubGraphOpenCLKernel::GenToFormatOp(const std::vector &in_te } new_tensor->CopyTensor(*in_tensors[i]); if (mem_type == MemType::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 4b1c022eca..2f1a3f0295 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 871d18fd11..7642ab643d 100644 --- a/mindspore/lite/src/sub_graph_kernel.cc +++ b/mindspore/lite/src/sub_graph_kernel.cc @@ -117,13 +117,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..ea74adcd27 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/src/train/train_session.cc b/mindspore/lite/src/train/train_session.cc index 1257089069..2d9bcfb7fa 100644 --- a/mindspore/lite/src/train/train_session.cc +++ b/mindspore/lite/src/train/train_session.cc @@ -74,14 +74,14 @@ void TrainSession::AllocWorkSpace() { size_t workspace_size = 0; for (auto ori_kernel : kernels_) { if (ori_kernel->subgraph_type() == kernel::kNotSubGraph) { - if (workspace_size < ori_kernel->GetWorkspaceSize()) { - workspace_size = ori_kernel->GetWorkspaceSize(); + if (workspace_size < ori_kernel->workspace_size()) { + workspace_size = ori_kernel->workspace_size(); } } else { auto sub_graph = reinterpret_cast(ori_kernel); for (auto kernel : sub_graph->nodes()) { - if (workspace_size < kernel->GetWorkspaceSize()) { - workspace_size = kernel->GetWorkspaceSize(); + if (workspace_size < kernel->workspace_size()) { + workspace_size = kernel->workspace_size(); } } } @@ -369,7 +369,7 @@ void TrainSession::MarkOptimizedKernels() { if (!IsOptimizer(kernel)) { for (auto it : kernel->in_tensors()) { if (std::find(ot.begin(), ot.end(), it) != ot.end()) { - kernel->SetTrainable(true); + kernel->set_trainable(true); break; } } @@ -380,7 +380,7 @@ void TrainSession::MarkOptimizedKernels() { if (!IsOptimizer(sb_kernel)) { for (auto it : sb_kernel->in_tensors()) { if (std::find(ot.begin(), ot.end(), it) != ot.end()) { - sb_kernel->SetTrainable(true); + sb_kernel->set_trainable(true); break; } } 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 1013b8b2bb..954d64b704 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 0b0995e4ff..f66464beca 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 01482e8b77..3b9e9b0d06 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/fp32_grad/bn_grad_fp32_test.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc index fd3d9c9ad2..ba626f30c8 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/bn_grad_fp32_test.cc @@ -87,7 +87,7 @@ TEST_F(TestBNGradFp32, BNGradFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(bn_param), &ctx, desc, nullptr); ASSERT_NE(kernel_obj, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->workspace_size()); kernel_obj->Run(); std::cout << "==========dx==========\n"; @@ -180,7 +180,7 @@ TEST_F(TestBNGradFp32, BNTtrainFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(bn_param), &context, desc, nullptr); ASSERT_NE(kernel_obj, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->workspace_size()); float *save_mean = reinterpret_cast(save_mean_tensor.MutableData()); float *save_var = reinterpret_cast(save_var_tensor.MutableData()); @@ -192,7 +192,7 @@ TEST_F(TestBNGradFp32, BNTtrainFp32) { float *curr_var = reinterpret_cast(var_tensor.MutableData()); kernel_obj->Train(); - kernel_obj->SetTrainable(true); + kernel_obj->set_trainable(true); kernel_obj->Run(); std::cout << "================save_mean==============================\n"; diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc index 0625adb70f..9c938f7e2a 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/convolution_grad_fp32_tests.cc @@ -119,7 +119,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { kernel->Run(); @@ -196,7 +196,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32InputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -272,7 +272,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupFilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { kernel->Run(); @@ -348,7 +348,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupInputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { kernel->Run(); @@ -423,7 +423,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupDilationFilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -499,7 +499,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32GroupDilationInputGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); int loop_count = 100; auto time_start = mindspore::lite::GetTimeUs(); @@ -569,7 +569,7 @@ TEST_F(TestConvolutionGradFp32, ConvGroupDilation) { outputs, &context, 0); ASSERT_NE(kernel, nullptr); kernel->Init(); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); kernel->Train(); EXPECT_EQ(kernel->IsTrain(), 1); @@ -676,7 +676,7 @@ TEST_F(TestConvolutionGradFp32, ConvFp32Dilation2Group2Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -783,7 +783,7 @@ TEST_F(TestConvolutionGradFp32, ConvGroup2Dilation2Stride2) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc index ecdee356e7..df7a5ae31c 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/deconvolution_grad_fp32_tests.cc @@ -98,7 +98,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -204,7 +204,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -313,7 +313,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group3FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -416,7 +416,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group3Stride1FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -522,7 +522,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group2Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { @@ -631,7 +631,7 @@ TEST_F(TestDeConvolutionGradFp32, DeConvFp32Dilation2Group12Stride2FilterGrad) { ASSERT_NE(creator, nullptr); auto kernel = creator(inputs, outputs, reinterpret_cast(conv_param), &context, desc, nullptr); ASSERT_NE(kernel, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel->workspace_size()); // warm up loop for (int i = 0; i < 3; i++) { diff --git a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc index 91de1005d4..4d6b756090 100644 --- a/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc +++ b/mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/softmax_crossentropy_fp32_tests.cc @@ -75,7 +75,7 @@ TEST_F(TestSoftmaxCrossEntropyFp32, SoftmaxCrossEntropyFp32) { ASSERT_NE(creator, nullptr); auto kernel_obj = creator(inputs, outputs, reinterpret_cast(sce_param), &context, desc, nullptr); ASSERT_NE(kernel_obj, nullptr); - mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->GetWorkspaceSize()); + mindspore::kernel::LiteKernel::AllocWorkspace(kernel_obj->workspace_size()); kernel_obj->Run(); printf("==================total loss=================\n"); 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 1ffc81fbf5..47b2b01c4f 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 b94072a575..f63df39122 100644 --- a/mindspore/lite/tools/anf_exporter/anf_exporter.cc +++ b/mindspore/lite/tools/anf_exporter/anf_exporter.cc @@ -95,10 +95,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++) { @@ -125,7 +125,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"; @@ -220,7 +220,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 cc9e3e9f6d..7d0b832e60 100644 --- a/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc +++ b/mindspore/lite/tools/converter/legacy_optimizer/graph/infershape_pass.cc @@ -149,7 +149,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 2d6d9abccd..45980e29d1 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; @@ -737,7 +737,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; @@ -765,7 +765,7 @@ STATUS PostTrainingQuantizer::DoBiasQuant(const AnfNodePtr &bias, const std::sha double filter_scale = std::abs(max_raw_data) / (activate_scale * quanted_bias_abs_limit); active_weight_quant_params[1][0].scale = filter_scale; active_weight_quant_params[1][0].zeroPoint = 0; - primitive_c->SetInputQuantParams(active_weight_quant_params); + primitive_c->set_input_quant_params(active_weight_quant_params); bias_scale_tmp = max_raw_data / quanted_bias_abs_limit; quant_params[0].scale = bias_scale_tmp; MS_LOG(DEBUG) << "new filter scale: " << filter_scale; @@ -820,7 +820,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; } @@ -843,16 +843,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 && @@ -875,7 +875,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 @@ -952,7 +952,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; @@ -1154,7 +1154,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; @@ -1212,7 +1212,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; @@ -1383,7 +1383,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 @@ -1470,7 +1470,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; @@ -1478,7 +1478,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 77a7f6110e..6820a7755b 100644 --- a/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/batchmatmul_fusion.cc @@ -153,13 +153,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 @@ -168,8 +168,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}; @@ -181,11 +181,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 20f6c53ae3..c00c38fd87 100644 --- a/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc +++ b/mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc @@ -90,7 +90,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]; @@ -211,7 +211,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{}; @@ -220,7 +220,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{}; @@ -233,7 +233,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 8e3d4edfad..60b42820b8 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/infershape_pass.cc b/mindspore/lite/tools/optimizer/graph/infershape_pass.cc index 6dcb0ad96d..65dcd67107 100644 --- a/mindspore/lite/tools/optimizer/graph/infershape_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/infershape_pass.cc @@ -40,7 +40,7 @@ abstract::AbstractTensorPtr InferShapePass::ConvertLiteTensorToAbstractTensor(li } new_value->set_tensor_shape(tensor->shape()); new_value->set_tensor_type(tensor->data_type()); - new_value->set_format(tensor->GetFormat()); + new_value->set_format(tensor->format()); new_abstract->set_value(new_value); return new_abstract; } @@ -150,7 +150,7 @@ STATUS InferShapePass::GetCNodeInputTensors(const CNodePtr &cnode, std::vectorset_shape(param_value_lite->tensor_shape()); tensor->set_data_type(param_value_lite->tensor_type()); - tensor->SetFormat(schema::Format(param_value_lite->format())); + tensor->set_format(schema::Format(param_value_lite->format())); if (utils::isa(input)) { auto parameter = input->cast(); @@ -251,7 +251,7 @@ bool InferShapePass::Run(const FuncGraphPtr &func_graph) { MS_LOG(ERROR) << "origin_primc is nullptr"; return false; } - auto origin_primt = origin_primc->GetPrimitiveT(); + auto origin_primt = origin_primc->primitiveT(); if (origin_primt == nullptr) { MS_LOG(ERROR) << "origin_primt is nullptr"; return false; diff --git a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc index 3a6a4e8fa4..0c0329c72f 100644 --- a/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc +++ b/mindspore/lite/tools/optimizer/graph/slice_prepose_pass.cc @@ -94,7 +94,7 @@ schema::SliceT *GetSliceT(const CNodePtr &cnode) { if (primc == nullptr) { return nullptr; } - auto primt = primc->GetPrimitiveT(); + auto primt = primc->primitiveT(); if (primt == nullptr || primt->value.AsSlice() == nullptr) { return nullptr; } @@ -109,7 +109,7 @@ schema::SoftMaxT *GetSoftmaxT(const CNodePtr &cnode) { if (primc == nullptr) { return nullptr; } - auto primt = primc->GetPrimitiveT(); + auto primt = primc->primitiveT(); if (primt == nullptr || primt->value.AsSoftMax() == nullptr) { return nullptr; } @@ -124,7 +124,7 @@ schema::ReshapeT *GetReshapeT(const CNodePtr &cnode) { if (primc == nullptr) { return nullptr; } - auto primt = primc->GetPrimitiveT(); + auto primt = primc->primitiveT(); if (primt == nullptr || primt->value.AsReshape() == nullptr) { return nullptr; } @@ -139,7 +139,7 @@ schema::FullConnectionT *GetFcT(const CNodePtr &cnode) { if (primc == nullptr) { return nullptr; } - auto primt = primc->GetPrimitiveT(); + auto primt = primc->primitiveT(); if (primt == nullptr || primt->value.AsFullConnection() == nullptr) { return nullptr; } @@ -230,7 +230,7 @@ ValueNodePtr SlicePreposePass::CopySliceValueNode(const FuncGraphPtr &graph, con MS_LOG(ERROR) << "primitive_c is nullptr"; return nullptr; } - auto primitive_t = primitive_c->GetPrimitiveT(); + auto primitive_t = primitive_c->primitiveT(); auto new_primitive_t = std::make_unique(); if (new_primitive_t == nullptr) { MS_LOG(ERROR) << "primitive_t is nullptr"; @@ -1057,7 +1057,7 @@ bool SlicePreposePass::PreposeWithTranspose(const FuncGraphPtr &graph, const CNo MS_LOG(ERROR) << "transpose_primc is nullptr"; return false; } - auto transpose_primt = transpose_primc->GetPrimitiveT(); + auto transpose_primt = transpose_primc->primitiveT(); if (transpose_primt == nullptr || transpose_primt->value.AsTranspose() == nullptr) { MS_LOG(ERROR) << "transpose_primt is nullptr"; 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 2493b3345d..ffa5c40894 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;