p83571920
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!9391 [MSLITE][Develop] fix code review 

From: @sunsuodong
Reviewed-by: @zhanghaibo5,@zhang_xue_tong,@zhang_xue_tong
Signed-off-by: @zhang_xue_tong,@zhang_xue_tong
This commit is contained in:
mindspore-ci-bot 2020-12-03 10:28:31 +08:00 committed by Gitee
parent 542b1ab76c dcd6f88b87
commit acdcd32fb7
47 changed files with 175 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mindspore/lite/nnacl/depth_to_space_parameter.h
View File

@ -19,13 +19,16 @@
typedef struct DepthToSpaceParameter {
OpParameter op_parameter_;
// primitive parameter
int32_t block_size_;
// shape correlative
int32_t in_stride_dim0_;
int32_t in_stride_dim1_;
int32_t in_stride_dim2_;
int32_t out_stride_dim0_;
int32_t out_stride_dim1_;
int32_t out_stride_dim2_;
// other parameter
uint8_t data_type_size_;
} DepthToSpaceParameter;

6
mindspore/lite/src/ops/assign.cc
View File

@ -71,7 +71,7 @@ int Assign::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
return RET_ERROR;
}
if (inputs[0]->ElementsNum() != inputs[1]->ElementsNum()) {
if (inputs.at(0)->ElementsNum() != inputs.at(1)->ElementsNum()) {
MS_LOG(ERROR) << "error input data size!";
return RET_ERROR;
}
@ -79,8 +79,8 @@ int Assign::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
if (!outputs.empty()) {
auto *out = outputs.front();
MS_ASSERT(out != nullptr);
out->set_data_type(inputs[0]->data_type());
out->set_format(inputs[0]->format());
out->set_data_type(inputs.at(0)->data_type());
out->set_format(inputs.at(0)->format());
out->set_shape({1});
}
return RET_OK;

8
mindspore/lite/src/ops/assign_add.cc
View File

@ -73,16 +73,16 @@ Registry AssignAddRegistry(schema::PrimitiveType_AssignAdd, AssignAddCreator);
#endif
int AssignAdd::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
Tensor *x = inputs_[0];
Tensor *y = inputs_[1];
Tensor *out = outputs_[0];
Tensor *x = inputs_.at(0);
Tensor *y = inputs_.at(1);
Tensor *out = outputs_.at(0);
std::vector<int> x_shape = x->shape();
if (x->data_type() != y->data_type()) {
MS_LOG(ERROR) << "no matched shape of x and y";
return RET_ERROR;
}
std::vector<int> output_shape(x_shape.size());
for (int i = 0; i < static_cast<int>(x_shape.size()); i++) {
for (size_t i = 0; i < x_shape.size(); i++) {
output_shape[i] = x_shape[i];
}
out->set_shape(output_shape);

4
mindspore/lite/src/ops/binary_cross_entropy.cc
View File

@ -100,8 +100,8 @@ PrimitiveC *BinaryCrossEntropyCreator(const schema::Primitive *primitive) {
Registry BinaryCrossEntropyRegistry(schema::PrimitiveType_BinaryCrossEntropy, BinaryCrossEntropyCreator);
#endif
int BinaryCrossEntropy::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
Tensor *x = inputs_[0];
Tensor *out = outputs_[0];
Tensor *x = inputs_.at(0);
Tensor *out = outputs_.at(0);
out->set_format(x->format());
out->set_data_type(x->data_type());
int reduction = GetReduction();

52
mindspore/lite/src/ops/conv2d.cc
View File

@ -89,10 +89,10 @@ void ConvertConvWeight(const ParameterPtr &param_node) {
return;
}
size_t filter_k = weight->tensor_shape()[0];
size_t filter_c = weight->tensor_shape()[1];
size_t filter_h = weight->tensor_shape()[2];
size_t filter_w = weight->tensor_shape()[3];
size_t filter_k = weight->tensor_shape().at(0);
size_t filter_c = weight->tensor_shape().at(1);
size_t filter_h = weight->tensor_shape().at(2);
size_t filter_w = weight->tensor_shape().at(3);
T *p1Buff = nullptr;
T *p2Buff = nullptr;
for (size_t k = 0; k < filter_k; ++k) {
@ -145,26 +145,26 @@ void Conv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::PrimitiveT
attr->format = schema::Format::Format_NUM_OF_FORMAT;
}
auto pad_list = CastToInt(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
attr->padUp = pad_list.at(0);
attr->padDown = pad_list.at(1);
attr->padLeft = pad_list.at(2);
attr->padRight = pad_list.at(3);
auto dilation = CastToInt(prim.GetAttr("dilation"));
#ifdef SUPPORT_TRAIN
attr->dilateH = dilation[2];
attr->dilateW = dilation[3];
attr->dilateH = dilation.at(2);
attr->dilateW = dilation.at(3);
#else
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
attr->dilateH = dilation.at(0);
attr->dilateW = dilation.at(1);
#endif
auto kernel_size = CastToInt(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
attr->kernelH = kernel_size.at(0);
attr->kernelW = kernel_size.at(1);
auto stride = CastToInt(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->strideH = stride.at(2);
attr->strideW = stride.at(3);
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
@ -229,22 +229,22 @@ void Conv2D::PopulaterConv2DSingleGroup(const Primitive &prim, schema::Primitive
attr->format = schema::Format::Format_NUM_OF_FORMAT;
}
auto pad_list = CastToInt(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
attr->padUp = pad_list.at(0);
attr->padDown = pad_list.at(1);
attr->padLeft = pad_list.at(2);
attr->padRight = pad_list.at(3);
auto dilation = CastToInt(prim.GetAttr("dilation"));
attr->dilateH = dilation[2];
attr->dilateW = dilation[3];
attr->dilateH = dilation.at(2);
attr->dilateW = dilation.at(3);
auto kernel_size = CastToInt(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
attr->kernelH = kernel_size.at(0);
attr->kernelW = kernel_size.at(1);
auto stride = CastToInt(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->strideH = stride.at(2);
attr->strideW = stride.at(3);
attr->channelOut = CastToInt(prim.GetAttr("out_channel")).front();

48
mindspore/lite/src/ops/deconv2d.cc
View File

@ -82,10 +82,10 @@ void ConvertConvWeight(const ParameterPtr &param_node) {
return;
}
size_t filter_k = weight->tensor_shape()[0];
size_t filter_c = weight->tensor_shape()[1];
size_t filter_h = weight->tensor_shape()[2];
size_t filter_w = weight->tensor_shape()[3];
size_t filter_k = weight->tensor_shape().at(0);
size_t filter_c = weight->tensor_shape().at(1);
size_t filter_h = weight->tensor_shape().at(2);
size_t filter_w = weight->tensor_shape().at(3);
T *p1Buff = nullptr;
T *p2Buff = nullptr;
for (size_t k = 0; k < filter_k; ++k) {
@ -137,22 +137,22 @@ void DeConv2D::PopulaterConv2DMultiGroup(const Primitive &prim, schema::Primitiv
attr->format = schema::Format::Format_NUM_OF_FORMAT;
}
auto pad_list = CastToInt(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
attr->padUp = pad_list.at(0);
attr->padDown = pad_list.at(1);
attr->padLeft = pad_list.at(2);
attr->padRight = pad_list.at(3);
auto dilation = CastToInt(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
attr->dilateH = dilation.at(0);
attr->dilateW = dilation.at(1);
auto kernel_size = CastToInt(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
attr->kernelH = kernel_size.at(0);
attr->kernelW = kernel_size.at(1);
auto stride = CastToInt(prim.GetAttr("stride"));
attr->strideH = stride[0];
attr->strideW = stride[1];
attr->strideH = stride.at(0);
attr->strideW = stride.at(1);
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
@ -204,22 +204,22 @@ void DeConv2D::PopulaterDeConv2DSingleGroup(const Primitive &prim, schema::Primi
attr->format = schema::Format_NUM_OF_FORMAT;
}
auto pad_list = CastToInt(prim.GetAttr("pad_list"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
attr->padUp = pad_list.at(0);
attr->padDown = pad_list.at(1);
attr->padLeft = pad_list.at(2);
attr->padRight = pad_list.at(3);
auto dilation = CastToInt(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
attr->dilateH = dilation.at(0);
attr->dilateW = dilation.at(1);
auto kernel_size = CastToInt(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
attr->kernelH = kernel_size.at(0);
attr->kernelW = kernel_size.at(1);
auto stride = CastToInt(prim.GetAttr("stride"));
attr->strideH = stride[0];
attr->strideW = stride[1];
attr->strideH = stride.at(0);
attr->strideW = stride.at(1);
attr->channelOut = CastToInt(prim.GetAttr("out_channel")).front();

24
mindspore/lite/src/ops/depthwise_conv2d.cc
View File

@ -87,19 +87,19 @@ int DepthwiseConv2D::UnPackAttr(const Primitive &prim, const std::vector<AnfNode
attr->format = schema::Format::Format_NUM_OF_FORMAT;
}
auto pad_list = CastToInt(prim.GetAttr("pads"));
attr->padUp = pad_list[0];
attr->padDown = pad_list[1];
attr->padLeft = pad_list[2];
attr->padRight = pad_list[3];
attr->padUp = pad_list.at(0);
attr->padDown = pad_list.at(1);
attr->padLeft = pad_list.at(2);
attr->padRight = pad_list.at(3);
auto dilation = CastToInt(prim.GetAttr("dilation"));
attr->dilateH = dilation[0];
attr->dilateW = dilation[1];
attr->dilateH = dilation.at(0);
attr->dilateW = dilation.at(1);
if (utils::isa<ValueSequeue>(prim.GetAttr("kernel_size"))) {
auto kernel_size = CastToInt(prim.GetAttr("kernel_size"));
attr->kernelH = kernel_size[0];
attr->kernelW = kernel_size[1];
attr->kernelH = kernel_size.at(0);
attr->kernelW = kernel_size.at(1);
} else {
auto kernel_size = CastToInt(prim.GetAttr("kernel_size")).front();
attr->kernelH = kernel_size;
@ -107,8 +107,8 @@ int DepthwiseConv2D::UnPackAttr(const Primitive &prim, const std::vector<AnfNode
}
auto stride = CastToInt(prim.GetAttr("stride"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->strideH = stride.at(2);
attr->strideW = stride.at(3);
auto pad_mode = GetValue<std::string>(prim.GetAttr("pad_mode"));
if (pad_mode == "valid") {
@ -252,11 +252,11 @@ int DepthwiseConv2D::InferShape(std::vector<lite::Tensor *> inputs_, std::vector
std::vector<int> out_shape{input->shape()};
out_shape.at(1) = output_h;
out_shape.at(2) = output_w;
if (GetChannelMultiplier() * input_channel != weight->shape()[0]) {
if (GetChannelMultiplier() * input_channel != weight->shape().at(0)) {
MS_LOG(ERROR) << "Conv depthwise only support group equals output channel.";
return 1;
}
out_shape.at(3) = weight->shape()[0] * weight->shape()[3]; // in_channel * out_channel
out_shape.at(3) = weight->shape().at(0) * weight->shape().at(3); // in_channel * out_channel
output->set_shape(out_shape);
return 0;

2
mindspore/lite/src/ops/populate/constant_of_shape_populate.cc
View File

@ -38,7 +38,7 @@ OpParameter *PopulateConstantOfShapeParameter(const mindspore::lite::PrimitiveC
if (value.empty() || value.size() > 1) {
MS_LOG(ERROR) << "The value of constant of shape is empty or more than 1.";
} else {
param->value_ = attr->GetValue()[0];
param->value_ = attr->GetValue().at(0);
}
param->data_type_ = attr->GetDataType();
return reinterpret_cast<OpParameter *>(param);

2
mindspore/lite/src/ops/strided_slice.cc
View File

@ -304,7 +304,7 @@ int StridedSlice::HandleAxesInputExist(const std::vector<lite::Tensor *> &inputs
std::vector<int> axes;
if (axes_data == nullptr) {
for (int i = 0; i < begin_ndim; ++i) {
axes[i] = i;
axes.push_back(i);
}
} else {
axes.assign(axes_data, axes_data + begin_ndim);

2
mindspore/lite/src/runtime/kernel/arm/base/arg_min_max_base.cc
View File

@ -59,7 +59,7 @@ int ArgMinMaxBaseCPUKernel::ReSize() {
MS_LOG(ERROR) << "Invalid topk " << param->topk_;
return RET_PARAM_INVALID;
}
param->topk_ = MSMIN(param->topk_, in_shape[axis]);
param->topk_ = MSMIN(param->topk_, in_shape.at(axis));
ComputeStrides(in_shape.data(), param->in_strides_, in_shape.size());
auto out_shape = out_tensors_.at(0)->shape();
ComputeStrides(out_shape.data(), param->out_strides_, out_shape.size());

4
mindspore/lite/src/runtime/kernel/arm/base/batch_to_space_base.cc
View File

@ -30,7 +30,7 @@ using mindspore::schema::PrimitiveType_BatchToSpaceND;
namespace mindspore::kernel {
int BatchToSpaceBaseCPUKernel::Init() {
if (in_tensors_[0]->format() != schema::Format::Format_NHWC) {
if (in_tensors_.at(0)->format() != schema::Format::Format_NHWC) {
MS_LOG(ERROR) << "batch_to_space only support NHWC now!";
return RET_FORMAT_ERR;
}
@ -44,7 +44,7 @@ int BatchToSpaceBaseCPUKernel::Init() {
}
int BatchToSpaceBaseCPUKernel::ReSize() {
auto shape = in_tensors_[0]->shape();
auto shape = in_tensors_.at(0)->shape();
if (shape.size() != 4) {
MS_LOG(ERROR) << "Unsupport shape size: " << shape.size();
return RET_ERROR;

8
mindspore/lite/src/runtime/kernel/arm/base/depth_to_space_base.cc
View File

@ -33,7 +33,7 @@ namespace mindspore::kernel {
int DepthToSpaceBaseCPUKernel::Init() { return RET_OK; }
int DepthToSpaceBaseCPUKernel::ReSize() {
if (in_tensors_[0]->format() != schema::Format::Format_NHWC) {
if (in_tensors_.at(0)->format() != schema::Format::Format_NHWC) {
MS_LOG(ERROR) << "depth_to_space only support NHWC now!";
return RET_FORMAT_ERR;
}
@ -42,18 +42,18 @@ int DepthToSpaceBaseCPUKernel::ReSize() {
MS_LOG(ERROR) << "Input block_size should > 0!";
return RET_PARAM_INVALID;
}
auto shape_size = in_tensors_[0]->shape().size();
auto shape_size = in_tensors_.at(0)->shape().size();
if (shape_size != DIMENSION_4D) {
MS_LOG(ERROR) << "Input shape size should be " << DIMENSION_4D;
return RET_PARAM_INVALID;
}
int32_t in_strides[DIMENSION_4D];
ComputeStrides(const_cast<int *>(in_tensors_[0]->shape().data()), in_strides, shape_size);
ComputeStrides(const_cast<int *>(in_tensors_.at(0)->shape().data()), in_strides, shape_size);
param->in_stride_dim0_ = in_strides[0];
param->in_stride_dim1_ = in_strides[1];
param->in_stride_dim2_ = in_strides[2];
int32_t out_strides[DIMENSION_4D];
ComputeStrides(const_cast<int *>(out_tensors_[0]->shape().data()), out_strides, shape_size);
ComputeStrides(const_cast<int *>(out_tensors_.at(0)->shape().data()), out_strides, shape_size);
param->out_stride_dim0_ = out_strides[0];
param->out_stride_dim1_ = out_strides[1];
param->out_stride_dim2_ = out_strides[2];

4
mindspore/lite/src/runtime/kernel/arm/base/dequant.h
View File

@ -44,8 +44,8 @@ class DequantUtil {
return nullptr;
}
if (input_tensor->shape().size() == kPerBatch &&
input_tensor->quant_params().size() == static_cast<size_t>(input_tensor->shape()[0])) { // per batch matmul
auto per_batch_size = input_tensor->shape()[0];
input_tensor->quant_params().size() == static_cast<size_t>(input_tensor->shape().at(0))) { // per batch matmul
auto per_batch_size = input_tensor->shape().at(0);
auto quant_param = input_tensor->quant_params();
for (int i = 0; i < per_batch_size; i++) {
auto param = quant_param.at(i);

4
mindspore/lite/src/runtime/kernel/arm/base/detection_post_process_base.cc
View File

@ -156,8 +156,8 @@ int DetectionPostProcessBaseCPUKernel::Run() {
auto output_scores = reinterpret_cast<float *>(out_tensors_.at(2)->MutableData());
auto output_num = reinterpret_cast<float *>(out_tensors_.at(3)->MutableData());
num_boxes_ = in_tensors_.at(0)->shape()[1];
num_classes_with_bg_ = in_tensors_.at(1)->shape()[2];
num_boxes_ = in_tensors_.at(0)->shape().at(1);
num_classes_with_bg_ = in_tensors_.at(1)->shape().at(2);
params_->decoded_boxes_ = context_->allocator->Malloc(num_boxes_ * 4 * sizeof(float));
if (params_->decoded_boxes_ == nullptr) {
MS_LOG(ERROR) << "malloc params->decoded_boxes_ failed.";

6
mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_compare_fp16.cc
View File

@ -74,9 +74,9 @@ int ArithmeticCompareFP16CPUKernel::Init() {
}
int ArithmeticCompareFP16CPUKernel::ReSize() {
param_->in_elements_num0_ = in_tensors_[0]->ElementsNum();
param_->in_elements_num1_ = in_tensors_[1]->ElementsNum();
param_->out_elements_num_ = out_tensors_[0]->ElementsNum();
param_->in_elements_num0_ = in_tensors_.at(0)->ElementsNum();
param_->in_elements_num1_ = in_tensors_.at(1)->ElementsNum();
param_->out_elements_num_ = out_tensors_.at(0)->ElementsNum();
if (param_->in_elements_num0_ == 1 || param_->in_elements_num1_ == 1) {
param_->broadcasting_ = false;

6
mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_fp16.cc
View File

@ -135,9 +135,9 @@ int ArithmeticFP16CPUKernel::PreProcess() {
}
int ArithmeticFP16CPUKernel::ReSize() {
param_->in_elements_num0_ = in_tensors_[0]->ElementsNum();
param_->in_elements_num1_ = in_tensors_[1]->ElementsNum();
param_->out_elements_num_ = out_tensors_[0]->ElementsNum();
param_->in_elements_num0_ = in_tensors_.at(0)->ElementsNum();
param_->in_elements_num1_ = in_tensors_.at(1)->ElementsNum();
param_->out_elements_num_ = out_tensors_.at(0)->ElementsNum();
if (param_->in_elements_num0_ == 1 || param_->in_elements_num1_ == 1) {
param_->broadcasting_ = false;

2
mindspore/lite/src/runtime/kernel/arm/fp16/arithmetic_self_fp16.cc
View File

@ -44,7 +44,7 @@ ArithmeticSelfFp16Func ArithmeticSelfFp16CPUKernel::GetArithmeticSelfFp16Fun(int
{mindspore::schema::PrimitiveType_Ceil, ElementCeilFp16},
{mindspore::schema::PrimitiveType_Round, ElementRoundFp16},
{mindspore::schema::PrimitiveType_Neg, ElementNegativeFp16}};
for (size_t i = 0; i < sizeof(type_func_table); i++) {
for (size_t i = 0; i < sizeof(type_func_table) / sizeof(TYPE_FUNC_INFO); i++) {
if (type_func_table[i].primitive_type_ == primitive_type) {
return type_func_table[i].func_;
}

2
mindspore/lite/src/runtime/kernel/arm/fp16/cast_fp16.cc
View File

@ -48,7 +48,7 @@ int CastFp16CPUKernel::Init() {
}
int CastFp16CPUKernel::ReSize() {
data_num_ = in_tensors_[0]->ElementsNum();
data_num_ = in_tensors_.at(0)->ElementsNum();
if (data_num_ == 0) {
return RET_OK;
}

2
mindspore/lite/src/runtime/kernel/arm/fp16/concat_fp16.cc
View File

@ -102,7 +102,7 @@ int ConcatFp16CPUKernel::Run() {
std::vector<std::vector<int>> shapes;
for (size_t i = 0; i < input_num; ++i) {
const auto in_tensor = in_tensors_[i];
const auto in_tensor = in_tensors_.at(i);
if (in_tensor->data_type() == kNumberTypeFloat || in_tensor->data_type() == kNumberTypeFloat32) {
auto in_tensor_data = reinterpret_cast<float *>(in_tensor->MutableData());
Float32ToFloat16(in_tensor_data, fp16_inputs_[i], in_tensor->ElementsNum());

2
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_fp16.cc
View File

@ -42,7 +42,7 @@ int ConvolutionDepthwiseFp16CPUKernel::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
ConvolutionBaseFP16CPUKernel::GetExecuteFilter();
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
int channel = weight_tensor->Batch();
int pack_weight_size = channel * weight_tensor->Height() * weight_tensor->Width();

2
mindspore/lite/src/runtime/kernel/arm/fp16/convolution_depthwise_slidewindow_fp16.cc
View File

@ -64,7 +64,7 @@ int ConvolutionDepthwiseSWFp16CPUKernel::InitPackedInputOutput() {
int ConvolutionDepthwiseSWFp16CPUKernel::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
int OC8 = UP_DIV(weight_tensor->Batch(), C8NUM);
auto origin_weight = reinterpret_cast<float *>(weight_tensor->MutableData());
int pack_weight_size = C8NUM * OC8 * weight_tensor->Height() * weight_tensor->Width();

2
mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_depthwise_fp16.cc
View File

@ -77,7 +77,7 @@ int DeconvolutionDepthwiseFp16CPUKernel::InitPackedInputOutput() {
int DeconvolutionDepthwiseFp16CPUKernel::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
int OC8 = UP_DIV(weight_tensor->Batch(), C8NUM);
auto origin_weight = reinterpret_cast<float *>(weight_tensor->MutableData());
int pack_weight_size = C8NUM * OC8 * weight_tensor->Height() * weight_tensor->Width();

4
mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_fp16.cc
View File

@ -64,7 +64,7 @@ int DeConvolutionFp16CPUKernel::InitWeightBias() {
}
memset(bias_data_, 0, UP_ROUND(output_channel, C4NUM) * sizeof(float16_t));
if (in_tensors_.size() == 3) {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[2]->MutableData()),
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_.at(2)->MutableData()),
reinterpret_cast<float16_t *>(bias_data_), output_channel);
}
@ -75,7 +75,7 @@ int DeConvolutionFp16CPUKernel::InitWeightBias() {
return RET_ERROR;
}
memset(execute_weight_, 0, weight_pack_size);
PackNHWCFp32ToC8HWN8Fp16(reinterpret_cast<float *>(in_tensors_[1]->MutableData()), execute_weight_, input_channel,
PackNHWCFp32ToC8HWN8Fp16(reinterpret_cast<float *>(in_tensors_.at(1)->MutableData()), execute_weight_, input_channel,
kernel_w * kernel_h, output_channel);
return RET_OK;
}

2
mindspore/lite/src/runtime/kernel/arm/fp16/deconvolution_winograd_fp16.cc
View File

@ -239,7 +239,7 @@ int DeConvWgPostFp16Run(void *cdata, int task_id) {
}
int DeConvWinogradFp16CPUKernel::InitComputeParam() {
auto weight_tensor = in_tensors_[1];
auto weight_tensor = in_tensors_.at(1);
conv_param_->input_channel_ = weight_tensor->Batch();
conv_param_->output_channel_ = weight_tensor->Channel();

1
mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_compare_fp32.cc
View File

@ -28,7 +28,6 @@ using mindspore::schema::PrimitiveType_LessEqual;
using mindspore::schema::PrimitiveType_NotEqual;
namespace mindspore::kernel {
int ArithmeticCompareCPUKernel::BroadcastRun(void *input0, void *input1, void *output, int dim, int out_count,
int out_thread_stride) {
if (dim > break_pos_) {

2
mindspore/lite/src/runtime/kernel/arm/fp32/arithmetic_self_fp32.cc
View File

@ -42,7 +42,7 @@ ArithmeticSelfFunc ArithmeticSelfCPUKernel::GetArithmeticSelfFun(int primitive_t
{mindspore::schema::PrimitiveType_Ceil, ElementCeil},
{mindspore::schema::PrimitiveType_Round, ElementRound},
{mindspore::schema::PrimitiveType_Neg, ElementNegative}};
for (size_t i = 0; i < sizeof(type_func_table); i++) {
for (size_t i = 0; i < sizeof(type_func_table) / sizeof(TYPE_FUNC_INFO); i++) {
if (type_func_table[i].primitive_type_ == primitive_type) {
return type_func_table[i].func_;
}

10
mindspore/lite/src/runtime/kernel/arm/fp32/batchnorm_fp32.cc
View File

@ -48,7 +48,7 @@ void BatchnormCPUKernel::FreeMeanAndVariance() {
}
void BatchnormCPUKernel::FillParam() {
auto input_shapes = in_tensors_[0]->shape();
auto input_shapes = in_tensors_.at(0)->shape();
auto n_dim = input_shapes.size();
auto param = reinterpret_cast<BatchNormParameter *>(op_parameter_);
param->channel_ = input_shapes[n_dim - 1];
@ -59,15 +59,15 @@ void BatchnormCPUKernel::FillParam() {
}
int BatchnormCPUKernel::InitConstTensor() {
mean_ = malloc(in_tensors_[1]->Size());
variance_ = malloc(in_tensors_[2]->Size());
mean_ = malloc(in_tensors_.at(1)->Size());
variance_ = malloc(in_tensors_.at(2)->Size());
if (mean_ == nullptr || variance_ == nullptr) {
MS_LOG(ERROR) << "Memory allocation failed";
FreeMeanAndVariance();
return RET_ERROR;
}
memcpy(mean_, in_tensors_[1]->MutableData(), in_tensors_[1]->Size());
memcpy(variance_, in_tensors_[2]->MutableData(), in_tensors_[2]->Size());
memcpy(mean_, in_tensors_.at(1)->MutableData(), in_tensors_.at(1)->Size());
memcpy(variance_, in_tensors_.at(2)->MutableData(), in_tensors_.at(2)->Size());
return RET_OK;
}

7
mindspore/lite/src/runtime/kernel/arm/fp32/bias_fp32.cc
View File

@ -29,9 +29,12 @@ using mindspore::schema::PrimitiveType_BiasAdd;
namespace mindspore::kernel {
int BiasCPUKernel::ReSize() {
auto dims = in_tensors_[0]->shape();
MS_ASSERT(dims.size() <= 5);
auto dims = in_tensors_.at(0)->shape();
bias_param_->ndim_ = dims.size();
if (bias_param_->ndim_ < 1 || bias_param_->ndim_ > 5) {
MS_LOG(ERROR) << "input shape is invalid";
return RET_ERROR;
}
for (size_t i = 0; i < bias_param_->ndim_; i++) {
bias_param_->in_shape0_[i] = dims[i];
bias_param_->in_shape1_[i] = 1;

4
mindspore/lite/src/runtime/kernel/arm/fp32/broadcast_to_fp32.cc
View File

@ -26,13 +26,13 @@ using mindspore::schema::PrimitiveType_BroadcastTo;
namespace mindspore::kernel {
int BroadcastToCPUKernel::ReSize() {
auto input_shape = in_tensors_[0]->shape();
auto input_shape = in_tensors_.at(0)->shape();
for (size_t i = 0; i < input_shape.size(); ++i) {
shape_info_.input_shape_[i] = input_shape[i];
}
shape_info_.input_shape_size_ = static_cast<int>(input_shape.size());
auto output_shape = out_tensors_[0]->shape();
auto output_shape = out_tensors_.at(0)->shape();
for (size_t i = 0; i < output_shape.size(); ++i) {
shape_info_.output_shape_[i] = output_shape[i];
}

2
mindspore/lite/src/runtime/kernel/arm/fp32/cast_fp32.cc
View File

@ -49,7 +49,7 @@ int CastCPUKernel::Init() {
}
int CastCPUKernel::ReSize() {
data_num_ = in_tensors_[0]->ElementsNum();
data_num_ = in_tensors_.at(0)->ElementsNum();
if (data_num_ == 0) {
return RET_OK;
}

7
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_fp32.cc
View File

@ -40,11 +40,14 @@ ConvolutionDepthwiseCPUKernel::~ConvolutionDepthwiseCPUKernel() {
int ConvolutionDepthwiseCPUKernel::InitWeightBias() {
// init weight: k, h, w, c; k == group == output_channel, c == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<float *>(weight_tensor->MutableData());
int channel = weight_tensor->Batch();
int pack_weight_size = weight_tensor->Batch() * weight_tensor->Height() * weight_tensor->Width();
if (pack_weight_size >= std::numeric_limits<int>::max() / static_cast<int>(sizeof(float))) {
MS_LOG(ERROR) << "pack_weight_size is invalid, pack_weight_size: " << pack_weight_size;
return RET_ERROR;
}
packed_weight_ = reinterpret_cast<float *>(malloc(pack_weight_size * sizeof(float)));
if (packed_weight_ == nullptr) {
MS_LOG(ERROR) << "Malloc buffer failed.";

4
mindspore/lite/src/runtime/kernel/arm/fp32/convolution_depthwise_slidewindow_fp32.cc
View File

@ -40,7 +40,7 @@ ConvolutionDepthwiseSWCPUKernel::~ConvolutionDepthwiseSWCPUKernel() {
int ConvolutionDepthwiseSWCPUKernel::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<float *>(weight_tensor->MutableData());
int OC4 = UP_DIV(weight_tensor->Batch(), C4NUM);
int pack_weight_size = C4NUM * OC4 * weight_tensor->Height() * weight_tensor->Width();
@ -66,7 +66,7 @@ int ConvolutionDepthwiseSWCPUKernel::InitWeightBias() {
memset(bias_data_, 0, malloc_size * sizeof(float));
if (in_tensors_.size() == kInputSize2) {
auto bias_tensor = in_tensors_[kBiasIndex];
auto bias_tensor = in_tensors_.at(kBiasIndex);
auto ori_bias = reinterpret_cast<float *>(bias_tensor->MutableData());
memcpy(bias_data_, ori_bias, bias_tensor->ElementsNum() * sizeof(float));
}

2
mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_depthwise_fp32.cc
View File

@ -54,7 +54,7 @@ int DeconvolutionDepthwiseCPUKernel::InitSlideParam() {
int DeconvolutionDepthwiseCPUKernel::InitWeightBias() {
// init weight: o, h, w, i; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<float *>(weight_tensor->MutableData());
int OC4 = UP_DIV(weight_tensor->Batch(), C4NUM);
int pack_weight_size = C4NUM * OC4 * weight_tensor->Height() * weight_tensor->Width();

4
mindspore/lite/src/runtime/kernel/arm/fp32/deconvolution_fp32.cc
View File

@ -63,7 +63,7 @@ int DeConvolutionCPUKernel::InitWeightBias() {
}
memset(bias_data_, 0, UP_ROUND(output_channel, C4NUM) * sizeof(float));
if (in_tensors_.size() == 3) {
memcpy(bias_data_, in_tensors_[2]->MutableData(), output_channel * sizeof(float));
memcpy(bias_data_, in_tensors_.at(2)->MutableData(), output_channel * sizeof(float));
}
size_t weight_pack_size = input_channel * kernel_w_ * kernel_h_ * UP_ROUND(output_channel, C8NUM) * sizeof(float);
@ -73,7 +73,7 @@ int DeConvolutionCPUKernel::InitWeightBias() {
return RET_ERROR;
}
memset(weight_ptr_, 0, weight_pack_size);
PackNHWCToC8HWN8Fp32(reinterpret_cast<float *>(in_tensors_[1]->MutableData()), weight_ptr_, input_channel,
PackNHWCToC8HWN8Fp32(reinterpret_cast<float *>(in_tensors_.at(1)->MutableData()), weight_ptr_, input_channel,
kernel_w_ * kernel_h_, output_channel);
return RET_OK;
}

5
mindspore/lite/src/runtime/kernel/arm/fp32/gatherNd_fp32.cc
View File

@ -56,7 +56,10 @@ int GatherNdCPUKernel::ReSize() {
for (int i = 0; i < indices_rank - 1; ++i) {
count_ *= indices_shape[i];
}
if (count_ >= std::numeric_limits<int>::max() / static_cast<int>(sizeof(int))) {
MS_LOG(ERROR) << "count_ is invalid, count_: " << count_;
return RET_ERROR;
}
in_offset_ = reinterpret_cast<int *>(malloc(count_ * sizeof(int)));
if (in_offset_ == nullptr) {
MS_LOG(ERROR) << "GatherNd Malloc in_offset_ error!";

4
mindspore/lite/src/runtime/kernel/arm/fp32/gather_fp32.cc
View File

@ -113,6 +113,10 @@ int GatherCPUKernel::Run() {
int GatherCPUKernel::AssignIndicesData(bool isIndicesInt32, int indices_num, lite::Tensor *indices_tensor) {
if (!isIndicesInt32) {
if (indices_num >= std::numeric_limits<int>::max() / static_cast<int>(sizeof(int))) {
MS_LOG(ERROR) << "Input indices_num is invalid, indices_num: " << indices_num;
return RET_ERROR;
}
indices_data_ = reinterpret_cast<int32_t *>(context_->allocator->Malloc(sizeof(int32_t) * indices_num));
if (indices_data_ == nullptr) {
MS_LOG(ERROR) << "Memory allocation failed";

8
mindspore/lite/src/runtime/kernel/arm/fp32/sparse_to_dense_fp32.cc
View File

@ -91,14 +91,18 @@ int SparseToDenseRun(void *cdata, int task_id) {
int SparseToDenseCPUKernel::GenerateIndices() {
auto input0 = in_tensors_.at(0);
index_dim = input0->shape().size();
index_num = input0->shape()[0];
int *sparse_indices = reinterpret_cast<int *>(input0->MutableData());
if (index_num >= std::numeric_limits<int>::max() / static_cast<int>(sizeof(int *))) {
MS_LOG(ERROR) << "Input dim is invalid, dim: " << index_num;
return RET_ERROR;
}
sparse_indices_vect = reinterpret_cast<int **>(ctx_->allocator->Malloc(sizeof(int *) * index_num));
if (sparse_indices_vect == nullptr) {
MS_LOG(ERROR) << "Null pointer reference: sparse_indices_vect.";
return RET_ERROR;
}
index_dim = input0->shape().size();
int *sparse_indices = reinterpret_cast<int *>(input0->MutableData());
switch (index_dim) {
case 0:
case 1: {

24
mindspore/lite/src/runtime/kernel/arm/int8/batchnorm_int8.cc
View File

@ -42,10 +42,10 @@ BatchnormInt8CPUKernel::~BatchnormInt8CPUKernel() {
}
int BatchnormInt8CPUKernel::InitConstTensor() {
auto input = in_tensors_[0];
auto mean = in_tensors_[1];
auto variance = in_tensors_[2];
auto output = out_tensors_[0];
auto input = in_tensors_.at(0);
auto mean = in_tensors_.at(1);
auto variance = in_tensors_.at(2);
auto output = out_tensors_.at(0);
auto mean_ptr = reinterpret_cast<int8_t *>(mean->MutableData());
auto var_ptr = reinterpret_cast<int8_t *>(variance->MutableData());
@ -81,12 +81,12 @@ int BatchnormInt8CPUKernel::InitConstTensor() {
}
int BatchnormInt8CPUKernel::InitFusedConstTensor() {
auto input = in_tensors_[0];
auto scale = in_tensors_[1];
auto offset = in_tensors_[2];
auto mean = in_tensors_[3];
auto variance = in_tensors_[4];
auto output = out_tensors_[0];
auto input = in_tensors_.at(0);
auto scale = in_tensors_.at(1);
auto offset = in_tensors_.at(2);
auto mean = in_tensors_.at(3);
auto variance = in_tensors_.at(4);
auto output = out_tensors_.at(0);
auto scale_ptr = reinterpret_cast<int8_t *>(scale->MutableData());
auto offset_ptr = reinterpret_cast<int8_t *>(offset->MutableData());
@ -133,7 +133,7 @@ int BatchnormInt8CPUKernel::InitFusedConstTensor() {
}
int BatchnormInt8CPUKernel::Init() {
auto input_shapes = in_tensors_[0]->shape();
auto input_shapes = in_tensors_.at(0)->shape();
auto n_dim = input_shapes.size();
batchnorm_param_->channel_ = input_shapes[n_dim - 1];
batchnorm_param_->units_ = 1;
@ -161,7 +161,7 @@ int BatchnormInt8CPUKernel::Init() {
}
int BatchnormInt8CPUKernel::ReSize() {
auto input_shapes = in_tensors_[0]->shape();
auto input_shapes = in_tensors_.at(0)->shape();
batchnorm_param_->unit_ = 1;
for (size_t i = 0; i < input_shapes.size() - 1; i++) {
batchnorm_param_->unit_ *= input_shapes[i];

9
mindspore/lite/src/runtime/kernel/arm/int8/bias_add_int8.cc
View File

@ -21,6 +21,7 @@
#include "include/errorcode.h"
using mindspore::lite::KernelRegistrar;
using mindspore::lite::RET_ERROR;
using mindspore::lite::RET_OK;
using mindspore::schema::PrimitiveType_BiasAdd;
@ -34,14 +35,18 @@ int BiasAddInt8CPUKernel::Init() {
int BiasAddInt8CPUKernel::ReSize() {
auto bias_param = reinterpret_cast<ArithmeticParameter *>(op_parameter_);
auto dims = in_tensors_[0]->shape();
auto dims = in_tensors_.at(0)->shape();
bias_param->ndim_ = dims.size();
if (bias_param->ndim_ < 1 || bias_param->ndim_ > 5) {
MS_LOG(ERROR) << "input shape is invalid";
return RET_ERROR;
}
for (size_t i = 0; i < bias_param->ndim_; i++) {
bias_param->in_shape0_[i] = dims[i];
bias_param->in_shape1_[i] = 1;
bias_param->out_shape_[i] = dims[i];
}
bias_param->in_shape1_[3] = dims[3];
bias_param->in_shape1_[bias_param->ndim_ - 1] = dims[bias_param->ndim_ - 1];
return RET_OK;
}

4
mindspore/lite/src/runtime/kernel/arm/int8/convolution_1x1_int8.cc
View File

@ -239,7 +239,7 @@ int Convolution1x1Int8CPUKernel::InitWeightBias() {
}
memset(bias_data_, 0, size * sizeof(int32_t));
if (in_tensors_.size() == 3) {
memcpy(bias_data_, in_tensors_[kBiasIndex]->data_c(), output_channel * sizeof(int32_t));
memcpy(bias_data_, in_tensors_.at(kBiasIndex)->data_c(), output_channel * sizeof(int32_t));
}
InitBiasByzp(filter_tensor->data_c(), input_channel, output_channel, size);
@ -271,7 +271,7 @@ int Convolution1x1Int8CPUKernel::InitWeightBiasArm32() {
}
memset(bias_data_, 0, col2 * sizeof(int32_t));
if (in_tensors_.size() == 3) {
memcpy(bias_data_, in_tensors_[kBiasIndex]->data_c(), output_channel * sizeof(int32_t));
memcpy(bias_data_, in_tensors_.at(kBiasIndex)->data_c(), output_channel * sizeof(int32_t));
}
InitBiasByzp(filter_tensor->MutableData(), input_channel, output_channel, col2);

2
mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_3x3_int8.cc
View File

@ -42,7 +42,7 @@ ConvolutionDepthwise3x3Int8CPUKernel::~ConvolutionDepthwise3x3Int8CPUKernel() {
int ConvolutionDepthwise3x3Int8CPUKernel::InitWeightBias() {
// init weight, int8 -> int16
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<int8_t *>(weight_tensor->MutableData());
int channel = weight_tensor->Batch();
if (channel % 8 != 0) {

5
mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_int8.cc
View File

@ -40,7 +40,7 @@ ConvolutionDepthwiseInt8CPUKernel::~ConvolutionDepthwiseInt8CPUKernel() {
int ConvolutionDepthwiseInt8CPUKernel::InitWeightBias() {
// init weight, int8 -> int16
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<int8_t *>(weight_tensor->MutableData());
int channel = weight_tensor->Batch();
int pack_weight_size = channel * weight_tensor->Height() * weight_tensor->Width();
@ -171,7 +171,8 @@ kernel::LiteKernel *CpuConvDwInt8KernelCreator(const std::vector<lite::Tensor *>
MS_ASSERT(opParameter != nullptr);
MS_ASSERT(desc.type == schema::PrimitiveType_DepthwiseConv2D);
kernel::LiteKernel *kernel = nullptr;
auto act_quant_size = MSMAX(inputs[kInputIndex]->quant_params().size(), outputs[kOutputIndex]->quant_params().size());
auto act_quant_size =
MSMAX(inputs.at(kInputIndex)->quant_params().size(), outputs.at(kOutputIndex)->quant_params().size());
if (act_quant_size == 1) { // per tensor
auto conv_param = reinterpret_cast<ConvParameter *>(opParameter);
if (primitive != nullptr && primitive->infer_flag()) {

2
mindspore/lite/src/runtime/kernel/arm/int8/convolution_depthwise_slidewindow_int8.cc
View File

@ -44,7 +44,7 @@ ConvolutionDepthwiseSWInt8CPUKernel::~ConvolutionDepthwiseSWInt8CPUKernel() {
int ConvolutionDepthwiseSWInt8CPUKernel::InitWeightBias() {
// init weight, int8 -> int16
// o, h, w, i -> o/8, h, w, i, 8; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<int8_t *>(weight_tensor->MutableData());
int OC8 = UP_DIV(weight_tensor->Batch(), C8NUM);
int pack_weight_size = C8NUM * OC8 * weight_tensor->Height() * weight_tensor->Width();

2
mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_depthwise_int8.cc
View File

@ -43,7 +43,7 @@ DeconvolutionDepthwiseInt8CPUKernel::~DeconvolutionDepthwiseInt8CPUKernel() {
int DeconvolutionDepthwiseInt8CPUKernel::InitWeightBias() {
// init weight: int8 -> int16
// o, h, w, i -> o/8, h, w, i, 8; o == group, i == 1
auto weight_tensor = in_tensors_[kWeightIndex];
auto weight_tensor = in_tensors_.at(kWeightIndex);
auto origin_weight = reinterpret_cast<int8_t *>(weight_tensor->MutableData());
int OC4 = UP_DIV(weight_tensor->Batch(), C4NUM);
int pack_weight_size = C4NUM * OC4 * weight_tensor->Height() * weight_tensor->Width();

4
mindspore/lite/src/runtime/kernel/arm/int8/deconvolution_int8.cc
View File

@ -132,7 +132,7 @@ int DeConvInt8CPUKernel::InitBiasWeight() {
}
memset(bias_data_, 0, size);
if (in_tensors_.size() == 3) {
memcpy(bias_data_, in_tensors_[0]->MutableData(), conv_param_->output_channel_ * sizeof(int32_t));
memcpy(bias_data_, in_tensors_.at(0)->MutableData(), conv_param_->output_channel_ * sizeof(int32_t));
}
size = UP_ROUND(conv_param_->output_channel_, C4NUM) * UP_ROUND(conv_param_->input_channel_, C16NUM) *
@ -143,7 +143,7 @@ int DeConvInt8CPUKernel::InitBiasWeight() {
return RET_ERROR;
}
memset(weight_ptr_, 0, size);
DeConvWeightTransInt8(reinterpret_cast<int8_t *>(in_tensors_[1]->MutableData()), weight_ptr_,
DeConvWeightTransInt8(reinterpret_cast<int8_t *>(in_tensors_.at(1)->MutableData()), weight_ptr_,
conv_param_->input_channel_, conv_param_->output_channel_,
conv_param_->kernel_h_ * conv_param_->kernel_w_, support_optimize_);

5
mindspore/lite/src/runtime/kernel/arm/int8/gatherNd_int8.cc
View File

@ -64,7 +64,10 @@ int GatherNdInt8CPUKernel::ReSize() {
for (int i = 0; i < indices_rank - 1; ++i) {
count_ *= indices_shape[i];
}
if (count_ >= std::numeric_limits<int>::max() / static_cast<int>(sizeof(int))) {
MS_LOG(ERROR) << "count_ is invalid, count_: " << count_;
return RET_ERROR;
}
in_offset_ = reinterpret_cast<int *>(malloc(count_ * sizeof(int)));
if (in_offset_ == nullptr) {
MS_LOG(ERROR) << "GatherNdInt8 Malloc in_offset_ error!";

4
mindspore/lite/tools/converter/parser/onnx/onnx_conv_parser.cc
View File

@ -164,8 +164,8 @@ STATUS OnnxConvParser::Parse(const onnx::GraphProto &onnx_graph, const onnx::Nod
}
dims.insert(dims.begin(), iter->ints().begin(), iter->ints().end());
}
attr->channelOut = dims[0];
attr->channelIn = dims[3] * attr->group;
attr->channelOut = dims.at(0);
attr->channelIn = dims.at(3) * attr->group;
}
attr->hasBias = onnx_node.input().size() == 3;
if (onnx_node.op_type() == "ConvRelu" || onnx_node.op_type() == "Int8ConvRelu") {