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

index use at

This commit is contained in:
zhaozhenlong 2020-12-01 11:14:40 +08:00
parent ae2e7b9db9
commit 0c7a7a27b3
48 changed files with 226 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -51,8 +51,8 @@ int ExpandDims::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr>
return RET_ERROR;
}
// use axis instead of dim
if (inputs[1]->isa<ValueNode>()) {
auto axis_tensor = inputs[1]->cast<ValueNodePtr>();
if (inputs.at(1)->isa<ValueNode>()) {
auto axis_tensor = inputs.at(1)->cast<ValueNodePtr>();
int axis = CastToInt(axis_tensor->value()).front();
attr->dim = axis;
} else {

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

@ -76,7 +76,7 @@ int Fill::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
std::vector<int> output_shape;
for (size_t i = 0; i < GetDims().size(); i++) {
output_shape.push_back(GetDims()[i]);
output_shape.push_back(GetDims().at(i));
}
output->set_shape(output_shape);
return RET_OK;

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

@ -45,10 +45,10 @@ int Flatten::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> out
auto input_shape = input->shape();
std::vector<int> output_shape(2);
output_shape[0] = input_shape[0];
output_shape[1] = 1;
output_shape.at(0) = input_shape.at(0);
output_shape.at(1) = 1;
for (size_t i = 1; i < input_shape.size(); i++) {
output_shape[1] *= input_shape[i];
output_shape.at(1) *= input_shape.at(i);
}
output->set_shape(output_shape);
return RET_OK;

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

@ -44,10 +44,10 @@ int FlattenGrad::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *>
auto input_shape = input->shape();
std::vector<int> output_shape(2);
output_shape[0] = input_shape[0];
output_shape[1] = 1;
output_shape.at(0) = input_shape.at(0);
output_shape.at(1) = 1;
for (size_t i = 1; i < input_shape.size(); i++) {
output_shape[1] *= input_shape[i];
output_shape.at(1) *= input_shape.at(i);
}
output->set_shape(output_shape);
return RET_OK;

20
mindspore/lite/src/ops/full_connection.cc
View File

@ -65,7 +65,7 @@ int FullConnection::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<
MS_ASSERT(this->primitive_ != nullptr);
auto input0 = inputs_.front();
MS_ASSERT(input0 != nullptr);
auto input1 = inputs_[1];
auto input1 = inputs_.at(1);
MS_ASSERT(input1 != nullptr);
auto output = outputs_.front();
MS_ASSERT(output != nullptr);
@ -83,34 +83,34 @@ int FullConnection::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<
int new_k = 1;
if (GetUseAxis()) {
for (size_t i = GetAxis(); i < input0->shape().size(); ++i) {
new_k *= input0->shape()[i];
new_k *= input0->shape().at(i);
}
if (new_k != input1->shape()[1]) {
if (new_k != input1->shape().at(1)) {
MS_LOG(ERROR) << "Input1 size invalid";
return RET_INPUT_TENSOR_ERROR;
}
} else {
new_k = input1->shape()[1];
new_k = input1->shape().at(1);
}
if (GetHasBias()) {
if (inputs_[2]->shape()[0] != input1->shape()[0]) {
if (inputs_.at(2)->shape().at(0) != input1->shape().at(0)) {
MS_LOG(ERROR) << "bias size invalid";
return RET_INPUT_TENSOR_ERROR;
}
}
std::vector<int> out_shape{inputs_[0]->shape()};
std::vector<int> out_shape{inputs_.at(0)->shape()};
if (GetUseAxis()) {
out_shape.resize(GetAxis() + 1);
out_shape[GetAxis()] = input1->shape()[0];
out_shape.at(GetAxis()) = input1->shape().at(0);
} else {
int total = 1;
for (size_t i = 0; i < input0->shape().size(); ++i) {
total *= input0->shape()[i];
total *= input0->shape().at(i);
}
out_shape.resize(2);
auto batch_size = total / new_k;
out_shape[0] = batch_size;
out_shape[1] = input1->shape()[0];
out_shape.at(0) = batch_size;
out_shape.at(1) = input1->shape().at(0);
}
output->set_shape(out_shape);
output->set_data_type(input0->data_type());

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

@ -57,8 +57,8 @@ int Gather::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inp
gather_attr = nullptr;
return RET_ERROR;
}
if (inputs[2]->isa<ValueNode>()) {
ValueNodePtr axis_tensor = inputs[2]->cast<ValueNodePtr>();
if (inputs.at(2)->isa<ValueNode>()) {
ValueNodePtr axis_tensor = inputs.at(2)->cast<ValueNodePtr>();
int axis = CastToInt(axis_tensor->value()).front();
gather_attr->axis = axis;
} else {
@ -137,7 +137,7 @@ int Gather::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
std::vector<int> out_shape{in_shape};
out_shape.erase(out_shape.begin() + axis);
for (int i = indices_rank - 1; i >= 0; --i) {
out_shape.insert(out_shape.begin() + axis, indices_shape[i]);
out_shape.insert(out_shape.begin() + axis, indices_shape.at(i));
}
output->set_shape(out_shape);
return RET_OK;

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

@ -72,17 +72,17 @@ int GatherNd::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> ou
int in_rank = in_shape.size();
auto indices_shape = indices->shape();
int indices_rank = indices_shape.size();
if (indices_shape[indices_rank - 1] > in_rank) {
if (indices_shape.at(indices_rank - 1) > in_rank) {
MS_LOG(ERROR) << "Input of indices data is error!";
return RET_ERROR;
}
std::vector<int> out_shape;
int i = 0;
for (i = 0; i < indices_rank - 1; ++i) {
out_shape.emplace_back(indices_shape[i]);
out_shape.emplace_back(indices_shape.at(i));
}
for (i = indices_shape[indices_rank - 1]; i < in_rank; ++i) {
out_shape.emplace_back(in_shape[i]);
for (i = indices_shape.at(indices_rank - 1); i < in_rank; ++i) {
out_shape.emplace_back(in_shape.at(i));
}
output->set_shape(out_shape);
return RET_OK;

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

@ -97,7 +97,7 @@ int LayerNorm::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite:
}
size_t first_index = input_shape.size() - normalized_shape.size();
for (size_t i = first_index; i < input_shape.size(); ++i) {
if (input_shape[i] != normalized_shape[i - first_index]) {
if (input_shape.at(i) != normalized_shape.at(i - first_index)) {
MS_LOG(INFO) << "normalized_shape attr invalid";
return RET_PARAM_INVALID;
}

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

@ -59,13 +59,13 @@ int Lstm::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
}
auto input = inputs_.front();
MS_ASSERT(input != nullptr);
auto weight_i = inputs_[1];
MS_ASSERT(input != nullptr);
auto weight_i = inputs_.at(1);
MS_ASSERT(weight_i != nullptr);
auto output = outputs_.front();
MS_ASSERT(output != nullptr);
for (int i = 0; i < kLstmOutputNum; i++) {
outputs_[i]->set_data_type(input->data_type());
outputs_[i]->set_format(input->format());
outputs_.at(i)->set_data_type(input->data_type());
outputs_.at(i)->set_format(input->format());
}
if (!infer_flag()) {
return RET_OK;

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

@ -125,7 +125,7 @@ int MatMul::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
del_end = true;
}
for (size_t i = 0; i < (a_shape.size() - 2) && i < (b_shape.size() - 2); ++i) {
if (a_shape[a_shape.size() - 3 - i] != b_shape[b_shape.size() - 3 - i]) {
if (a_shape.at(a_shape.size() - 3 - i) != b_shape.at(b_shape.size() - 3 - i)) {
MS_LOG(ERROR) << "Op MatMul's dimensions must be equal";
return RET_INPUT_TENSOR_ERROR;
}

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

@ -103,7 +103,7 @@ int Mean::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
for (size_t i = 0; i < in_shape.size(); i++) {
bool reduce_axis = false;
for (size_t idx = 0; idx < num_axes; ++idx) {
if (static_cast<size_t>(axes[idx]) == i) {
if (static_cast<size_t>(axes.at(idx)) == i) {
reduce_axis = true;
break;
}
@ -113,7 +113,7 @@ int Mean::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
out_shape.push_back(1);
}
} else {
out_shape.push_back(in_shape[i]);
out_shape.push_back(in_shape.at(i));
}
}
output->set_shape(out_shape);

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

@ -72,8 +72,8 @@ PrimitiveC *OnesLikeCreator(const schema::Primitive *primitive) {
Registry OnesLikeRegistry(schema::PrimitiveType_OnesLike, OnesLikeCreator);
#endif
int OnesLike::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);
std::vector<int> x_shape = x->shape();
std::vector<int> output_shape(x_shape.size());
output_shape.assign(x_shape.begin(), x_shape.end());

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

@ -110,7 +110,7 @@ int Pad::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> outputs)
MS_ASSERT(input->shape().size() <= 4);
for (size_t i = 0; i < input_shape.size(); i++) {
auto paddings_index = i;
auto shape = input_shape[i] + paddings[2 * paddings_index] + paddings[2 * paddings_index + 1];
auto shape = input_shape.at(i) + paddings.at(2 * paddings_index) + paddings.at(2 * paddings_index + 1);
output_shape.push_back(shape);
}

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

@ -111,12 +111,12 @@ int Pooling::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &in
}
auto kernel_size = CastToInt(prim.GetAttr("ksize"));
attr->windowH = kernel_size[2];
attr->windowW = kernel_size[3];
attr->windowH = kernel_size.at(2);
attr->windowW = kernel_size.at(3);
auto stride = CastToInt(prim.GetAttr("strides"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->strideH = stride.at(2);
attr->strideW = stride.at(3);
this->primitive_->value.value = attr;
if (this->primitive_->value.value == nullptr) {
MS_LOG(ERROR) << "primitive value is nullptr";

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

@ -100,12 +100,12 @@ int PoolingGrad::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr>
}
auto kernel_size = CastToInt(prim.GetAttr("ksize"));
attr->windowH = kernel_size[2];
attr->windowW = kernel_size[3];
attr->windowH = kernel_size.at(2);
attr->windowW = kernel_size.at(3);
auto stride = CastToInt(prim.GetAttr("strides"));
attr->strideH = stride[2];
attr->strideW = stride[3];
attr->strideH = stride.at(2);
attr->strideW = stride.at(3);
this->primitive_->value.value = attr;
if (this->primitive_->value.value == nullptr) {
MS_LOG(ERROR) << "primitive value is nullptr";

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

@ -103,14 +103,14 @@ Registry PowerRegistry(schema::PrimitiveType_Power, PowerCreator);
int Power::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> outputs) {
MS_ASSERT(this->primitive_ != nullptr);
auto x_tensor = inputs[0];
auto x_tensor = inputs.at(0);
MS_ASSERT(x_tensor != nullptr);
Tensor *exp_tensor = nullptr;
if (inputs.size() == 2) {
exp_tensor = inputs[1];
exp_tensor = inputs.at(1);
MS_ASSERT(exp_tensor != nullptr);
}
auto output_tensor = outputs[0];
auto output_tensor = outputs.at(0);
MS_ASSERT(output_tensor != nullptr);
output_tensor->set_data_type(x_tensor->data_type());
output_tensor->set_format(x_tensor->format());
@ -119,7 +119,7 @@ int Power::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> output
}
if (exp_tensor != nullptr) {
if ((exp_tensor->shape().size() > 1 && exp_tensor->shape() != x_tensor->shape()) ||
(exp_tensor->shape().size() == 1 && exp_tensor->shape()[0] != 1) ||
(exp_tensor->shape().size() == 1 && exp_tensor->shape().at(0) != 1) ||
exp_tensor->data_type() != x_tensor->data_type()) {
MS_LOG(ERROR) << "Power inputs shape or type is not equal!";
return RET_INPUT_TENSOR_ERROR;

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

@ -331,7 +331,7 @@ void PrimitiveC::GetAttrDataFromInput(const AnfNodePtr &inputNode, std::vector<i
auto tuple = val->cast<ValueTuplePtr>();
MS_ASSERT(tuple != nullptr);
for (size_t i = 0; i < tuple->size(); i++) {
auto elem = tuple->value()[i];
auto elem = tuple->value().at(i);
MS_ASSERT(elem != nullptr);
data->emplace_back(CastToInt(elem).front());
}
@ -349,7 +349,7 @@ void PrimitiveC::set_input_quant_params(const std::vector<std::vector<schema::Qu
void PrimitiveC::set_input_quant_param(const size_t &index, const std::vector<schema::QuantParamT> &input_quant_param) {
MS_ASSERT(index < this->input_quant_param_.size());
this->input_quant_param_[index] = input_quant_param;
this->input_quant_param_.at(index) = input_quant_param;
}
void PrimitiveC::set_output_quant_params(const std::vector<std::vector<schema::QuantParamT>> &output_quant_param) {
@ -359,7 +359,7 @@ void PrimitiveC::set_output_quant_params(const std::vector<std::vector<schema::Q
void PrimitiveC::set_output_quant_param(const size_t &index,
const std::vector<schema::QuantParamT> &output_quant_param) {
MS_ASSERT(index < this->output_quant_param_.size());
this->output_quant_param_[index] = output_quant_param;
this->output_quant_param_.at(index) = output_quant_param;
}
bool PrimitiveC::IsInputQuantParamsInited() {

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

@ -58,11 +58,11 @@ int PriorBoxCPUKernel::Init() {
int PriorBoxCPUKernel::ReSize() { return GeneratePriorBox(); }
int PriorBoxCPUKernel::GeneratePriorBox() {
const int fmap_w = in_tensors_[0]->Width();
const int fmap_h = in_tensors_[0]->Height();
const int fmap_w = in_tensors_.at(0)->Width();
const int fmap_h = in_tensors_.at(0)->Height();
const int image_w = prior_box_param_->image_size_w > 0 ? prior_box_param_->image_size_w : in_tensors_[1]->Width();
const int image_h = prior_box_param_->image_size_h > 0 ? prior_box_param_->image_size_h : in_tensors_[1]->Height();
const int image_w = prior_box_param_->image_size_w > 0 ? prior_box_param_->image_size_w : in_tensors_.at(1)->Width();
const int image_h = prior_box_param_->image_size_h > 0 ? prior_box_param_->image_size_h : in_tensors_.at(1)->Height();
const float step_w =
prior_box_param_->step_w > 0.0f ? prior_box_param_->step_w : static_cast<float>(image_w) / fmap_w;

44
mindspore/lite/src/runtime/kernel/arm/fp16/fullconnection_fp16.cc
View File

@ -54,10 +54,10 @@ void FullconnectionFP16CPUKernel::FreeTmpBuffer() {
int FullconnectionFP16CPUKernel::ReSize() {
FreeTmpBuffer();
int row = 1;
for (size_t i = 0; i < out_tensors_[0]->shape().size() - 1; ++i) row *= (out_tensors_[0]->shape())[i];
for (size_t i = 0; i < out_tensors_.at(0)->shape().size() - 1; ++i) row *= (out_tensors_.at(0)->shape())[i];
fc_param_->row_ = row;
fc_param_->col_ = out_tensors_[0]->shape().back();
fc_param_->deep_ = (in_tensors_[1]->shape())[1];
fc_param_->col_ = out_tensors_.at(0)->shape().back();
fc_param_->deep_ = (in_tensors_.at(1)->shape()).at(1);
fc_param_->row_16_ = UP_ROUND(fc_param_->row_, C16NUM);
fc_param_->col_8_ = UP_ROUND(fc_param_->col_, C8NUM);
thread_count_ = MSMIN(thread_count_, UP_DIV(fc_param_->col_, C8NUM));
@ -89,21 +89,21 @@ int FullconnectionFP16CPUKernel::ReSize() {
}
memset(b_pack_ptr_, 0, b_pack_col * fc_param_->deep_ * sizeof(float16_t));
fc_param_->b_const_ = (in_tensors_[1]->data_c() != nullptr);
fc_param_->b_const_ = (in_tensors_.at(1)->data_c() != nullptr);
if (fc_param_->b_const_) {
if (in_tensors_[1]->data_type() == kNumberTypeFloat32) {
if (in_tensors_.at(1)->data_type() == kNumberTypeFloat32) {
if (is_vector_input_) {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_,
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_,
fc_param_->col_ * fc_param_->deep_);
} else {
InitMatrixB(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
}
} else {
if (is_vector_input_) {
memcpy(b_pack_ptr_, reinterpret_cast<float16_t *>(in_tensors_[1]->data_c()),
memcpy(b_pack_ptr_, reinterpret_cast<float16_t *>(in_tensors_.at(1)->data_c()),
fc_param_->col_ * fc_param_->deep_ * sizeof(float16_t));
} else {
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
}
}
b_ptr_ = b_pack_ptr_;
@ -116,10 +116,10 @@ int FullconnectionFP16CPUKernel::ReSize() {
return RET_MEMORY_FAILED;
}
memset(bias_ptr_, 0, b_pack_col * sizeof(float16_t));
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[2]->data_c()), bias_ptr_, fc_param_->col_);
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_.at(2)->data_c()), bias_ptr_, fc_param_->col_);
}
if (out_tensors_[0]->data_type() == kNumberTypeFloat32) {
if (out_tensors_.at(0)->data_type() == kNumberTypeFloat32) {
output_fp16_ =
reinterpret_cast<float16_t *>(ctx_->allocator->Malloc(fc_param_->row_ * fc_param_->col_ * sizeof(float16_t)));
if (output_fp16_ == nullptr) {
@ -183,43 +183,43 @@ int FcFP16Run(void *cdata, int task_id) {
}
int FullconnectionFP16CPUKernel::Run() {
auto out_tensor = out_tensors_[0];
auto out_tensor = out_tensors_.at(0);
if (out_tensor->data_type() == kNumberTypeFloat32) {
output_ptr_ = output_fp16_;
} else {
output_ptr_ = reinterpret_cast<float16_t *>(out_tensor->data_c());
}
if (in_tensors_[0]->data_type() == kNumberTypeFloat32) {
if (in_tensors_.at(0)->data_type() == kNumberTypeFloat32) {
if (is_vector_input_) {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[0]->data_c()), a_pack_ptr_, fc_param_->deep_);
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_.at(0)->data_c()), a_pack_ptr_, fc_param_->deep_);
} else {
InitMatrixA(reinterpret_cast<float *>(in_tensors_[0]->data_c()), a_pack_ptr_);
InitMatrixA(reinterpret_cast<float *>(in_tensors_.at(0)->data_c()), a_pack_ptr_);
}
a_ptr_ = a_pack_ptr_;
} else {
if (is_vector_input_) {
a_ptr_ = reinterpret_cast<float16_t *>(in_tensors_[0]->data_c());
a_ptr_ = reinterpret_cast<float16_t *>(in_tensors_.at(0)->data_c());
} else {
InitMatrixA(reinterpret_cast<float16_t *>(in_tensors_[0]->data_c()), a_pack_ptr_);
InitMatrixA(reinterpret_cast<float16_t *>(in_tensors_.at(0)->data_c()), a_pack_ptr_);
a_ptr_ = a_pack_ptr_;
}
}
if (!fc_param_->b_const_) {
if (in_tensors_[1]->data_type() == kNumberTypeFloat32) {
if (in_tensors_.at(1)->data_type() == kNumberTypeFloat32) {
if (is_vector_input_) {
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_,
Float32ToFloat16(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_,
fc_param_->col_ * fc_param_->deep_);
} else {
InitMatrixB(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
}
b_ptr_ = b_pack_ptr_;
} else {
if (is_vector_input_) {
b_ptr_ = reinterpret_cast<float16_t *>(in_tensors_[1]->data_c());
b_ptr_ = reinterpret_cast<float16_t *>(in_tensors_.at(1)->data_c());
} else {
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
b_ptr_ = b_pack_ptr_;
}
}

14
mindspore/lite/src/runtime/kernel/arm/fp16/group_convolution_fp16.cc
View File

@ -28,7 +28,7 @@ using mindspore::schema::PrimitiveType_Conv2D;
namespace mindspore::kernel {
int GroupConvolutionFP16CPUKernel::Init() {
for (int i = 0; i < group_num_; ++i) {
auto ret = group_convs_[i]->Init();
auto ret = group_convs_.at(i)->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Sub kernel init failed.";
return ret;
@ -40,7 +40,7 @@ int GroupConvolutionFP16CPUKernel::Init() {
int GroupConvolutionFP16CPUKernel::ReSize() {
for (int i = 0; i < group_num_; ++i) {
auto ret = group_convs_[i]->ReSize();
auto ret = group_convs_.at(i)->ReSize();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Sub kernel resize failed.";
return RET_ERROR;
@ -94,7 +94,7 @@ int GroupConvolutionFP16CPUKernel::PreProcess() {
int in_w = conv_param_->input_w_;
int in_c = conv_param_->input_channel_;
in_shape = {in_batch, in_h, in_w, in_c};
auto sub_kernel_in_tensor = group_convs_[i]->in_tensors().front();
auto sub_kernel_in_tensor = group_convs_.at(i)->in_tensors().front();
sub_kernel_in_tensor->set_shape(in_shape);
ret = sub_kernel_in_tensor->MallocData();
if (ret != RET_OK) {
@ -141,9 +141,9 @@ int GroupConvolutionFP16CPUKernel::SeparateInput(int group_id) {
int in_plane = in_h * in_w;
int sub_in_channel = conv_param_->input_channel_;
int ori_in_channel = sub_in_channel * group_num_;
auto sub_in_data = group_convs_[group_id]->in_tensors().front()->data_c();
auto sub_in_data = group_convs_.at(group_id)->in_tensors().front()->data_c();
auto in_data_type = in_tensors_.front()->data_type();
auto sub_in_data_type = group_convs_[group_id]->in_tensors().front()->data_type();
auto sub_in_data_type = group_convs_.at(group_id)->in_tensors().front()->data_type();
if (in_data_type != sub_in_data_type) {
MS_LOG(ERROR) << "data type of sub conv kernel input should be the same as origin input's.";
return RET_ERROR;
@ -183,7 +183,7 @@ void GroupConvolutionFP16CPUKernel::PostConcat(int group_id) {
int out_plane = out_h * out_w;
int sub_out_channel = conv_param_->output_channel_;
int ori_out_channel = sub_out_channel * group_num_;
auto sub_out_data = reinterpret_cast<float16_t *>(group_convs_[group_id]->out_tensors().front()->data_c());
auto sub_out_data = reinterpret_cast<float16_t *>(group_convs_.at(group_id)->out_tensors().front()->data_c());
MS_ASSERT(sub_out_data);
float16_t *src_ptr = sub_out_data;
float16_t *dst_ptr = ori_out_data_ + group_id * sub_out_channel;
@ -206,7 +206,7 @@ int GroupConvolutionFP16CPUKernel::Run() {
return ret;
}
// sun kernels run
ret = group_convs_[i]->Run();
ret = group_convs_.at(i)->Run();
if (ret != RET_OK) {
MS_LOG(ERROR) << "sub kernel " << i << " execute failed.";
return ret;

14
mindspore/lite/src/runtime/kernel/arm/fp16/matmul_fp16.cc
View File

@ -262,7 +262,7 @@ int MatmulFP16Run(void *cdata, int task_id) {
}
int MatmulFP16CPUKernel::Run() {
auto out_tensor = out_tensors_[0];
auto out_tensor = out_tensors_.at(0);
auto ret = MallocFp16Output();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Matmul MallocFp16Output failed";
@ -280,10 +280,10 @@ int MatmulFP16CPUKernel::Run() {
MS_LOG(ERROR) << "Matmul fp16 malloc matrix A buffer failed";
return RET_ERROR;
}
if (in_tensors_[0]->data_type() == kNumberTypeFloat32) {
InitMatrixA(reinterpret_cast<float *>(in_tensors_[0]->data_c()), a_pack_ptr_);
if (in_tensors_.at(0)->data_type() == kNumberTypeFloat32) {
InitMatrixA(reinterpret_cast<float *>(in_tensors_.at(0)->data_c()), a_pack_ptr_);
} else {
InitMatrixA(reinterpret_cast<float16_t *>(in_tensors_[0]->data_c()), a_pack_ptr_);
InitMatrixA(reinterpret_cast<float16_t *>(in_tensors_.at(0)->data_c()), a_pack_ptr_);
}
}
if (!params_->b_const_) {
@ -292,10 +292,10 @@ int MatmulFP16CPUKernel::Run() {
MS_LOG(ERROR) << "Matmul fp16 malloc matrix B buffer failed";
return RET_ERROR;
}
if (in_tensors_[1]->data_type() == kNumberTypeFloat32) {
InitMatrixB(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_);
if (in_tensors_.at(1)->data_type() == kNumberTypeFloat32) {
InitMatrixB(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
} else {
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float16_t *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
}
}
for (int i = 0; i < params_->batch; ++i) {

16
mindspore/lite/src/runtime/kernel/arm/fp16/quant_dtype_cast_fp16.cc
View File

@ -115,14 +115,14 @@ int QuantDTypeCastFP16Run(void *cdata, int task_id) {
}
int QuantDTypeCastFp16CPUKernel::Run() {
if (in_tensors_[0]->data_type() == TypeId::kNumberTypeInt8 &&
out_tensors_[0]->data_type() == TypeId::kNumberTypeFloat16) {
int8_ptr_ = reinterpret_cast<int8_t *>(in_tensors_[0]->data_c());
float16_ptr_ = reinterpret_cast<float16_t *>(out_tensors_[0]->data_c());
} else if (in_tensors_[0]->data_type() == TypeId::kNumberTypeFloat16 &&
out_tensors_[0]->data_type() == TypeId::kNumberTypeInt8) {
float16_ptr_ = reinterpret_cast<float16_t *>(in_tensors_[0]->data_c());
int8_ptr_ = reinterpret_cast<int8_t *>(out_tensors_[0]->data_c());
if (in_tensors_.at(0)->data_type() == TypeId::kNumberTypeInt8 &&
out_tensors_.at(0)->data_type() == TypeId::kNumberTypeFloat16) {
int8_ptr_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->data_c());
float16_ptr_ = reinterpret_cast<float16_t *>(out_tensors_.at(0)->data_c());
} else if (in_tensors_.at(0)->data_type() == TypeId::kNumberTypeFloat16 &&
out_tensors_.at(0)->data_type() == TypeId::kNumberTypeInt8) {
float16_ptr_ = reinterpret_cast<float16_t *>(in_tensors_.at(0)->data_c());
int8_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->data_c());
} else {
MS_LOG(ERROR) << "QuantDTypeCastFp16 not support input or output type";
return RET_ERROR;

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

@ -48,14 +48,14 @@ int ExpandDimsCPUKernel::DoExpandDims(int task_id) {
return RET_OK;
}
int offset = task_id * thread_sz_stride_;
if (this->in_tensors_[0]->data_type() == kNumberTypeFloat32) {
if (this->in_tensors_.at(0)->data_type() == kNumberTypeFloat32) {
int ret = ExpandDims(reinterpret_cast<float *>(in_ptr_) + offset, reinterpret_cast<float *>(out_ptr_) + offset,
size * sizeof(float));
if (ret != RET_OK) {
MS_LOG(ERROR) << "ExpandDimsRun error task_id[" << task_id << "] error_code[" << ret << "]";
return ret;
}
} else if (this->in_tensors_[0]->data_type() == kNumberTypeInt8) {
} else if (this->in_tensors_.at(0)->data_type() == kNumberTypeInt8) {
int ret = ExpandDims(reinterpret_cast<int8_t *>(in_ptr_) + offset, reinterpret_cast<int8_t *>(out_ptr_) + offset,
size * sizeof(int8_t));
if (ret != RET_OK) {

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

@ -35,17 +35,17 @@ int FlattenCPUKernel::Init() {
}
int FlattenCPUKernel::ReSize() {
auto output_shape = out_tensors_[0]->shape();
auto output_shape = out_tensors_.at(0)->shape();
flatten_param_->size = sizeof(float);
for (size_t i = 0; i < output_shape.size(); i++) {
flatten_param_->size *= output_shape[i];
flatten_param_->size *= output_shape.at(i);
}
return RET_OK;
}
int FlattenCPUKernel::Run() {
auto input = reinterpret_cast<float *>(in_tensors_[0]->MutableData());
auto output = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
auto input = reinterpret_cast<float *>(in_tensors_.at(0)->MutableData());
auto output = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
Flatten(input, output, flatten_param_);
return RET_OK;
}

16
mindspore/lite/src/runtime/kernel/arm/fp32/fullconnection_fp32.cc
View File

@ -44,12 +44,12 @@ void FullconnectionCPUKernel::FreeBuf() {
int FullconnectionCPUKernel::ReSize() {
FreeBuf();
int row = 1;
for (size_t i = 0; i < out_tensors_[0]->shape().size() - 1; ++i) {
row *= (out_tensors_[0]->shape())[i];
for (size_t i = 0; i < out_tensors_.at(0)->shape().size() - 1; ++i) {
row *= (out_tensors_.at(0)->shape())[i];
}
fc_param_->row_ = row;
fc_param_->col_ = out_tensors_[0]->shape().back();
fc_param_->deep_ = (in_tensors_[1]->shape())[1];
fc_param_->col_ = out_tensors_.at(0)->shape().back();
fc_param_->deep_ = (in_tensors_.at(1)->shape()).at(1);
fc_param_->row_12_ = UP_ROUND(fc_param_->row_, C12NUM);
fc_param_->col_8_ = UP_ROUND(fc_param_->col_, C8NUM);
@ -98,14 +98,14 @@ int FullconnectionCPUKernel::ReSize() {
}
memset(b_pack_ptr_, 0, col_tmp * fc_param_->deep_ * sizeof(float));
fc_param_->a_const_ = (in_tensors_[0]->data_c() != nullptr);
fc_param_->b_const_ = (in_tensors_[1]->data_c() != nullptr);
fc_param_->a_const_ = (in_tensors_.at(0)->data_c() != nullptr);
fc_param_->b_const_ = (in_tensors_.at(1)->data_c() != nullptr);
if (fc_param_->a_const_) {
InitMatrixA(reinterpret_cast<float *>(in_tensors_[0]->MutableData()), a_pack_ptr_);
InitMatrixA(reinterpret_cast<float *>(in_tensors_.at(0)->MutableData()), a_pack_ptr_);
a_ptr_ = a_pack_ptr_;
}
if (fc_param_->b_const_) {
InitMatrixB(reinterpret_cast<float *>(in_tensors_[1]->MutableData()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float *>(in_tensors_.at(1)->MutableData()), b_pack_ptr_);
b_ptr_ = b_pack_ptr_;
}
return RET_OK;

32
mindspore/lite/src/runtime/kernel/arm/fp32/fused_batchnorm_fp32.cc
View File

@ -42,10 +42,10 @@ void FusedBatchnormCPUKernel::FreeScaleAndOffset() {
}
int FusedBatchnormCPUKernel::InitConstTensor() {
auto scale = in_tensors_[1];
auto offset = in_tensors_[2];
auto mean = in_tensors_[3];
auto variance = in_tensors_[4];
auto scale = in_tensors_.at(1);
auto offset = in_tensors_.at(2);
auto mean = in_tensors_.at(3);
auto variance = in_tensors_.at(4);
scale_ = malloc(scale->Size());
offset_ = malloc(offset->Size());
@ -82,10 +82,10 @@ int FusedBatchnormCPUKernel::Run() {
FusedBatchNormFp32MeanVar(in, current_mean, current_var, param, static_cast<float *>(save_mean),
static_cast<float *>(save_variance));
memcpy(out_tensors_[1]->MutableData(), scale, out_tensors_[1]->Size());
memcpy(out_tensors_[2]->MutableData(), offset, out_tensors_[2]->Size());
memcpy(out_tensors_[3]->MutableData(), current_mean, out_tensors_[3]->Size());
memcpy(out_tensors_[4]->MutableData(), current_var, out_tensors_[4]->Size());
memcpy(out_tensors_.at(1)->MutableData(), scale, out_tensors_.at(1)->Size());
memcpy(out_tensors_.at(2)->MutableData(), offset, out_tensors_.at(2)->Size());
memcpy(out_tensors_.at(3)->MutableData(), current_mean, out_tensors_.at(3)->Size());
memcpy(out_tensors_.at(4)->MutableData(), current_var, out_tensors_.at(4)->Size());
// Copy to local variables
memcpy(scale_, scale, in_tensors_[1]->Size());
@ -108,16 +108,16 @@ int FusedBatchnormCPUKernel::Run() {
int FusedBatchnormCPUKernel::Eval() {
LiteKernel::Eval();
if (trained_) {
float *save_mean = static_cast<float *>(in_tensors_[3]->MutableData());
float *save_var = static_cast<float *>(in_tensors_[4]->MutableData());
float *scale = static_cast<float *>(in_tensors_[1]->MutableData());
float *bias = static_cast<float *>(in_tensors_[2]->MutableData());
float *save_mean = static_cast<float *>(in_tensors_.at(3)->MutableData());
float *save_var = static_cast<float *>(in_tensors_.at(4)->MutableData());
float *scale = static_cast<float *>(in_tensors_.at(1)->MutableData());
float *bias = static_cast<float *>(in_tensors_.at(2)->MutableData());
// Copy to local variables
memcpy(scale_, scale, in_tensors_[1]->Size());
memcpy(offset_, bias, in_tensors_[2]->Size());
memcpy(mean_, save_mean, in_tensors_[3]->Size());
memcpy(variance_, save_var, in_tensors_[4]->Size());
memcpy(scale_, scale, in_tensors_.at(1)->Size());
memcpy(offset_, bias, in_tensors_.at(2)->Size());
memcpy(mean_, save_mean, in_tensors_.at(3)->Size());
memcpy(variance_, save_var, in_tensors_.at(4)->Size());
}
return RET_OK;
}

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

@ -84,7 +84,7 @@ int GatherNdCPUKernel::ReSize() {
int idx_stride = idx_lastshape;
for (int j = 0; j < count_; ++j) {
for (int k = 0; k < idx_lastshape; ++k) {
in_offset_[j] += indices_ptr[j * idx_stride + k] * in_stride[k];
in_offset_[j] += indices_ptr[j * idx_stride + k] * in_stride.at(k);
}
}

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

@ -55,14 +55,14 @@ int GatherCPUKernel::DoGather(int task_id) {
int indices_element_size = indices_tensor->ElementsNum();
auto axis = (reinterpret_cast<GatherParameter *>(op_parameter_))->axis_;
const int limit = in_shape[axis];
const int limit = in_shape.at(axis);
int outer_size = 1, inner_size = 1;
for (int i = 0; i < axis; ++i) {
outer_size *= in_shape[i];
outer_size *= in_shape.at(i);
}
for (int i = axis + 1; i < in_rank; ++i) {
inner_size *= in_shape[i];
inner_size *= in_shape.at(i);
}
int stride = UP_DIV(outer_size, op_parameter_->thread_num_);
int count = MSMIN(stride, outer_size - stride * task_id);

14
mindspore/lite/src/runtime/kernel/arm/fp32/group_convolution_fp32.cc
View File

@ -28,7 +28,7 @@ using mindspore::schema::PrimitiveType_Conv2D;
namespace mindspore::kernel {
int GroupConvolutionCPUKernel::Init() {
for (int i = 0; i < group_num_; ++i) {
auto ret = group_convs_[i]->Init();
auto ret = group_convs_.at(i)->Init();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Sub kernel init failed.";
return ret;
@ -40,7 +40,7 @@ int GroupConvolutionCPUKernel::Init() {
int GroupConvolutionCPUKernel::ReSize() {
for (int i = 0; i < group_num_; ++i) {
auto ret = group_convs_[i]->ReSize();
auto ret = group_convs_.at(i)->ReSize();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Sub kernel resize failed.";
return RET_ERROR;
@ -94,7 +94,7 @@ int GroupConvolutionCPUKernel::PreProcess() {
int in_w = conv_param_->input_w_;
int in_c = conv_param_->input_channel_;
in_shape = {in_batch, in_h, in_w, in_c};
auto sub_kernel_in_tensor = group_convs_[i]->in_tensors().front();
auto sub_kernel_in_tensor = group_convs_.at(i)->in_tensors().front();
sub_kernel_in_tensor->set_shape(in_shape);
ret = sub_kernel_in_tensor->MallocData();
if (ret != RET_OK) {
@ -108,7 +108,7 @@ int GroupConvolutionCPUKernel::PreProcess() {
int out_w = conv_param_->output_w_;
int out_c = conv_param_->output_channel_;
out_shape = {out_batch, out_h, out_w, out_c};
auto sub_kernel_out_tensors = group_convs_[i]->out_tensors();
auto sub_kernel_out_tensors = group_convs_.at(i)->out_tensors();
for (auto tensor : sub_kernel_out_tensors) {
tensor->set_shape(out_shape);
ret = tensor->MallocData();
@ -140,7 +140,7 @@ void GroupConvolutionCPUKernel::SeparateInput(int group_id) {
int in_plane = in_h * in_w;
int sub_in_channel = conv_param_->input_channel_;
int ori_in_channel = sub_in_channel * group_num_;
auto sub_in_data = reinterpret_cast<float *>(group_convs_[group_id]->in_tensors().front()->data_c());
auto sub_in_data = reinterpret_cast<float *>(group_convs_.at(group_id)->in_tensors().front()->data_c());
float *src_ptr = ori_in_data_ + group_id * sub_in_channel;
float *dst_ptr = sub_in_data;
for (int i = 0; i < in_plane; ++i) {
@ -156,7 +156,7 @@ void GroupConvolutionCPUKernel::PostConcat(int group_id) {
int out_plane = out_h * out_w;
int sub_out_channel = conv_param_->output_channel_;
int ori_out_channel = sub_out_channel * group_num_;
auto sub_out_data = reinterpret_cast<float *>(group_convs_[group_id]->out_tensors().front()->data_c());
auto sub_out_data = reinterpret_cast<float *>(group_convs_.at(group_id)->out_tensors().front()->data_c());
float *src_ptr = sub_out_data;
float *dst_ptr = ori_out_data_ + group_id * sub_out_channel;
for (int i = 0; i < out_plane; ++i) {
@ -173,7 +173,7 @@ int GroupConvolutionCPUKernel::Run() {
// first, separate group conv input into several parts. This step must be in runtime stage.
SeparateInput(i);
// sun kernels run
auto ret = group_convs_[i]->Run();
auto ret = group_convs_.at(i)->Run();
if (ret != RET_OK) {
MS_LOG(ERROR) << "sub kernel " << i << " execute failed.";
return ret;

6
mindspore/lite/src/runtime/kernel/arm/fp32/instance_norm_fp32.cc
View File

@ -36,12 +36,12 @@ int InstanceNormCPUKernel::Init() {
int InstanceNormCPUKernel::ReSize() {
auto input_shapes = in_tensors_.front()->shape();
auto n_dim = input_shapes.size();
outer_size_ = input_shapes[0] * input_shapes[n_dim - 1];
outer_size_ = input_shapes.at(0) * input_shapes.at(n_dim - 1);
inner_size_ = 1;
for (size_t i = 0; i < n_dim - 1; ++i) {
inner_size_ *= input_shapes[i];
inner_size_ *= input_shapes.at(i);
}
param_->channel_ = input_shapes[n_dim - 1];
param_->channel_ = input_shapes.at(n_dim - 1);
return RET_OK;
}

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

@ -39,9 +39,9 @@ int LayerNormCPUKernel::ReSize() {
inner_size_ = 1;
for (size_t i = 0; i < shape.size(); ++i) {
if (i + param_->normalized_dims_ < shape.size()) {
outer_size_ *= shape[i];
outer_size_ *= shape.at(i);
} else {
inner_size_ *= shape[i];
inner_size_ *= shape.at(i);
}
}
return RET_OK;

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

@ -42,10 +42,10 @@ int LocalResponseNormCPUKernel::DoLocalResponseNorm(int task_id) {
auto in_shape = input_tensor->shape();
MS_ASSERT(in_shape.size() == 4);
int batch = in_shape[0];
int height = in_shape[1];
int width = in_shape[2];
int channel = in_shape[3];
int batch = in_shape.at(0);
int height = in_shape.at(1);
int width = in_shape.at(2);
int channel = in_shape.at(3);
int outer_size = batch * width * height;
int stride = UP_DIV(outer_size, thread_count_);

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

@ -50,14 +50,14 @@ int LstmCPUKernel::InitParam() {
auto input = in_tensors_.front();
MS_ASSERT(input != nullptr);
std::vector<int> in_shape = input->shape();
lstm_parm_->seq_len_ = in_shape[0];
lstm_parm_->batch_ = in_shape[1];
lstm_parm_->input_size_ = in_shape[2];
lstm_parm_->seq_len_ = in_shape.at(0);
lstm_parm_->batch_ = in_shape.at(1);
lstm_parm_->input_size_ = in_shape.at(2);
auto weight_i = in_tensors_[1];
auto weight_i = in_tensors_.at(1);
MS_ASSERT(weight_i != nullptr);
std::vector<int> w_shape = weight_i->shape();
lstm_parm_->hidden_size_ = w_shape[1] / 4;
lstm_parm_->hidden_size_ = w_shape.at(1) / 4;
lstm_parm_->input_step_ = lstm_parm_->batch_ * lstm_parm_->input_size_;
lstm_parm_->output_step_ = lstm_parm_->bidirectional_ ? 2 * lstm_parm_->batch_ * lstm_parm_->hidden_size_

32
mindspore/lite/src/runtime/kernel/arm/fp32/matmul_fp32.cc
View File

@ -58,8 +58,9 @@ void MatmulCPUKernel::FreeTmpBuffer() {
}
int MatmulCPUKernel::MallocMatrixABuffer() {
auto a_shape = in_tensors_[0]->shape();
auto a_shape = in_tensors_.at(0)->shape();
int batch = 1;
MS_ASSERT(a_shape.size() >= 2);
for (size_t i = 0; i < a_shape.size() - 2; ++i) {
batch *= a_shape[i];
}
@ -102,11 +103,12 @@ int MatmulCPUKernel::MallocMatrixABuffer() {
}
int MatmulCPUKernel::MallocMatrixBBuffer() {
auto b_shape = in_tensors_[1]->shape();
auto b_shape = in_tensors_.at(1)->shape();
if (b_shape.empty()) {
return RET_OK;
}
int batch = 1;
MS_ASSERT(b_shape.size() >= 2);
for (size_t i = 0; i < b_shape.size() - 2; ++i) {
batch *= b_shape[i];
}
@ -133,11 +135,11 @@ int MatmulCPUKernel::MallocMatrixBBuffer() {
}
int MatmulCPUKernel::InitBias() {
auto b_shape = in_tensors_[1]->shape();
auto c_shape = out_tensors_[0]->shape();
auto b_shape = in_tensors_.at(1)->shape();
auto c_shape = out_tensors_.at(0)->shape();
params_->col_ = params_->b_const_
? (params_->b_transpose_ ? b_shape[b_shape.size() - 2] : b_shape[b_shape.size() - 1])
: (c_shape[c_shape.size() - 1]);
? (params_->b_transpose_ ? b_shape.at(b_shape.size() - 2) : b_shape.at(b_shape.size() - 1))
: (c_shape.at(c_shape.size() - 1));
params_->col_8_ = UP_ROUND(params_->col_, 8);
auto col_tmp = is_vector_a_ ? params_->col_ : params_->col_8_;
if (bias_ptr_ == nullptr) {
@ -221,15 +223,15 @@ void MatmulCPUKernel::InitMatrixB(const float *src_ptr, float *dst_ptr) {
}
int MatmulCPUKernel::Init() {
params_->a_const_ = (in_tensors_[0]->data_c() != nullptr);
params_->b_const_ = (in_tensors_[1]->data_c() != nullptr);
params_->a_const_ = (in_tensors_.at(0)->data_c() != nullptr);
params_->b_const_ = (in_tensors_.at(1)->data_c() != nullptr);
if (params_->a_const_) {
auto ret = MallocMatrixABuffer();
if (ret != RET_OK) {
MS_LOG(ERROR) << "Matmul fp32 malloc matrix Ａ buffer failed";
return RET_ERROR;
}
InitMatrixA(reinterpret_cast<float *>(in_tensors_[0]->data_c()), a_pack_ptr_);
InitMatrixA(reinterpret_cast<float *>(in_tensors_.at(0)->data_c()), a_pack_ptr_);
a_ptr_ = a_pack_ptr_;
}
if (params_->b_const_) {
@ -238,7 +240,7 @@ int MatmulCPUKernel::Init() {
MS_LOG(ERROR) << "Matmul fp32 malloc matrix B buffer failed";
return RET_ERROR;
}
InitMatrixB(reinterpret_cast<float *>(in_tensors_[1]->data_c()), b_pack_ptr_);
InitMatrixB(reinterpret_cast<float *>(in_tensors_.at(1)->data_c()), b_pack_ptr_);
b_ptr_ = b_pack_ptr_;
// init bias
ret = InitBias();
@ -281,9 +283,9 @@ int MatmulFloatRun(void *cdata, int task_id) {
}
int MatmulCPUKernel::Run() {
auto a_src = reinterpret_cast<float *>(in_tensors_[0]->data_c());
auto b_src = reinterpret_cast<float *>(in_tensors_[1]->data_c());
auto c_src = reinterpret_cast<float *>(out_tensors_[0]->data_c());
auto a_src = reinterpret_cast<float *>(in_tensors_.at(0)->data_c());
auto b_src = reinterpret_cast<float *>(in_tensors_.at(1)->data_c());
auto c_src = reinterpret_cast<float *>(out_tensors_.at(0)->data_c());
if (!params_->a_const_ || IsTrain()) {
if (a_pack_ptr_ != nullptr) {
@ -356,8 +358,8 @@ int MatmulCPUKernel::Run() {
int MatmulCPUKernel::Eval() {
// Copy weights after training
auto a_src = reinterpret_cast<float *>(in_tensors_[0]->data_c());
auto b_src = reinterpret_cast<float *>(in_tensors_[1]->data_c());
auto a_src = reinterpret_cast<float *>(in_tensors_.at(0)->data_c());
auto b_src = reinterpret_cast<float *>(in_tensors_.at(1)->data_c());
LiteKernel::Eval();
if (params_->a_const_) {
if (a_pack_ptr_ == nullptr) {

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

@ -28,8 +28,8 @@ int Nchw2NhwcCPUKernel::Init() { return RET_OK; }
int Nchw2NhwcCPUKernel::ReSize() { return RET_OK; }
int Nchw2NhwcCPUKernel::Run() {
auto input = in_tensors_[0];
auto output = out_tensors_[0];
auto input = in_tensors_.at(0);
auto output = out_tensors_.at(0);
if (input->shape().size() == 4) {
if (input->data_type() == kNumberTypeFloat32) {

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

@ -28,8 +28,8 @@ int Nhwc2NchwCPUKernel::Init() { return RET_OK; }
int Nhwc2NchwCPUKernel::ReSize() { return RET_OK; }
int Nhwc2NchwCPUKernel::Run() {
auto input = in_tensors_[0];
auto output = out_tensors_[0];
auto input = in_tensors_.at(0);
auto output = out_tensors_.at(0);
if (input->shape().size() == 4) {
if (input->data_type() == kNumberTypeFloat32) {

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

@ -122,13 +122,13 @@ int NonMaxSuppressionCPUKernel::Run() {
return RET_ERROR;
}
constexpr size_t kBatchIndex = 0;
if (score_dims[kBatchIndex] != box_dims[kBatchIndex]) {
if (score_dims.at(kBatchIndex) != box_dims.at(kBatchIndex)) {
MS_LOG(ERROR) << "Boxes tensor batch num should be equal to scores tensor's batch num.";
return RET_ERROR;
}
constexpr size_t kScoreDimsBoxNumIndex = 2;
constexpr size_t kBoxDimsBoxNumIndex = 1;
if (score_dims[kScoreDimsBoxNumIndex] != box_dims[kBoxDimsBoxNumIndex]) {
if (score_dims.at(kScoreDimsBoxNumIndex) != box_dims.at(kBoxDimsBoxNumIndex)) {
MS_LOG(ERROR) << "Boxes tensor spatial dimension should be equal to scores tensor's spatial dimension.";
return RET_ERROR;
}
@ -138,10 +138,10 @@ int NonMaxSuppressionCPUKernel::Run() {
return RET_ERROR;
}
int batch_num = score_dims[kBatchIndex];
int batch_num = score_dims.at(kBatchIndex);
constexpr size_t kClassIndex = 1;
int class_num = score_dims[kClassIndex];
int box_num = score_dims[kScoreDimsBoxNumIndex];
int class_num = score_dims.at(kClassIndex);
int box_num = score_dims.at(kScoreDimsBoxNumIndex);
float *scores_data = reinterpret_cast<float *>(score_tensor->data_c());
if (scores_data == nullptr) {
MS_LOG(ERROR) << "score tensor data nullptr";

6
mindspore/lite/src/runtime/kernel/arm/fp32/power_fp32.cc
View File

@ -50,11 +50,11 @@ int PowerCPUKernel::Run() {
}
int PowerCPUKernel::RunImpl(int task_id) {
auto x_addr = reinterpret_cast<float *>(in_tensors_[0]->MutableData());
auto x_addr = reinterpret_cast<float *>(in_tensors_.at(0)->MutableData());
MS_ASSERT(x_addr);
auto output_addr = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
auto output_addr = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_addr);
auto size = in_tensors_[0]->ElementsNum();
auto size = in_tensors_.at(0)->ElementsNum();
int stride = UP_DIV(size, thread_count_);
int len = MSMIN(stride, size - stride * task_id);
float *exp_addr = nullptr;

6
mindspore/lite/src/runtime/kernel/arm/fp32/prelu_fp32.cc
View File

@ -52,13 +52,13 @@ int PReluCPUKernel::DoExcute(int task_id) {
int PReluCPUKernel::ProcessInput() {
// input tensor
auto input_tensor = in_tensors_[0];
auto input_tensor = in_tensors_.at(0);
auto in_shape = input_tensor->shape();
auto n_dim = in_shape.size();
auto channel_num = in_shape.at(n_dim - 1);
int input_plane = 1;
for (size_t i = 0; i < n_dim - 1; ++i) {
input_plane *= in_shape[i];
input_plane *= in_shape.at(i);
}
int tile_block = UP_DIV(input_plane, TILE_NUM);
prelu_param_->input_num_ = input_tensor->ElementsNum();
@ -76,7 +76,7 @@ int PReluCPUKernel::ProcessInput() {
int PReluCPUKernel::ProcessShareChannelInput() {
// input tensor
auto input_tensor = in_tensors_[0];
auto input_tensor = in_tensors_.at(0);
prelu_param_->input_num_ = input_tensor->ElementsNum();
#ifdef ENABLE_ARM64
prelu_param_->tile_block_ = UP_DIV(prelu_param_->input_num_, 64);

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

@ -34,7 +34,7 @@ int RankCPUKernel::ReSize() { return RET_OK; }
int RankCPUKernel::Run() {
auto output_ptr = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_ptr);
auto in_shape = in_tensors_[0]->shape();
auto in_shape = in_tensors_.at(0)->shape();
auto rank = in_shape.size();
Rank(output_ptr, rank);
return RET_OK;

26
mindspore/lite/src/runtime/kernel/arm/int8/fullconnection_int8.cc
View File

@ -74,7 +74,7 @@ void FullconnectionInt8CPUKernel::FreeTmpBuffer() {
}
int FullconnectionInt8CPUKernel::MallocQuantParam() {
auto weight_tensor = in_tensors_[1];
auto weight_tensor = in_tensors_.at(1);
auto weight_quant_params = weight_tensor->quant_params();
int col = weight_tensor->shape().front();
filter_per_channel_ = (weight_quant_params.size() > 1);
@ -111,15 +111,15 @@ int FullconnectionInt8CPUKernel::Init() {
return ret;
}
auto in_quant_params = in_tensors_[0]->quant_params();
auto in_quant_params = in_tensors_.at(0)->quant_params();
quant_.input_.zp_ = in_quant_params.front().zeroPoint;
quant_.input_.scale_ = in_quant_params.front().scale;
auto out_quant_params = out_tensors_[0]->quant_params();
auto out_quant_params = out_tensors_.at(0)->quant_params();
quant_.output_.zp_ = out_quant_params.front().zeroPoint;
quant_.output_.scale_ = out_quant_params.front().scale;
auto weight_tensor = in_tensors_[1];
auto weight_tensor = in_tensors_.at(1);
fc_param_->b_const_ = (weight_tensor->data_c() != nullptr);
int weight_quant_num = filter_per_channel_ ? weight_tensor->shape().front() : 1;
auto weight_quant_params = weight_tensor->quant_params();
@ -148,12 +148,12 @@ int FullconnectionInt8CPUKernel::Init() {
void FullconnectionInt8CPUKernel::InitParam() {
int row = 1;
for (size_t i = 0; i < out_tensors_[0]->shape().size() - 1; ++i) {
row *= (out_tensors_[0]->shape())[i];
for (size_t i = 0; i < out_tensors_.at(0)->shape().size() - 1; ++i) {
row *= (out_tensors_.at(0)->shape()).at(i);
}
fc_param_->row_ = row;
fc_param_->col_ = out_tensors_[0]->shape().back();
fc_param_->deep_ = (in_tensors_[1]->shape())[1];
fc_param_->col_ = out_tensors_.at(0)->shape().back();
fc_param_->deep_ = (in_tensors_.at(1)->shape()).at(1);
fc_param_->row_4_ = UP_ROUND(fc_param_->row_, C4NUM);
fc_param_->row_8_ = UP_ROUND(fc_param_->row_, C8NUM);
@ -207,13 +207,13 @@ int FullconnectionInt8CPUKernel::ReSize() {
FreeTmpBuffer();
return RET_MEMORY_FAILED;
}
memcpy(bias_ptr_, in_tensors_[2]->data_c(), fc_param_->col_ * sizeof(int));
memcpy(bias_ptr_, in_tensors_.at(2)->data_c(), fc_param_->col_ * sizeof(int));
} else {
bias_ptr_ = nullptr;
}
if (fc_param_->b_const_) {
auto weight_data = reinterpret_cast<int8_t *>(in_tensors_[1]->data_c());
auto weight_data = reinterpret_cast<int8_t *>(in_tensors_.at(1)->data_c());
RowMajor2Row16x4MajorInt8(weight_data, pack_b_ptr_, fc_param_->col_, fc_param_->deep_);
CalcWeightBiasSums(weight_data, fc_param_->deep_, fc_param_->col_, quant_.input_.zp_, quant_.filter_zp_, bias_ptr_,
weight_bias_sums_, ColMajor, filter_per_channel_);
@ -254,20 +254,20 @@ int FcInt8Run(void *cdata, int task_id) {
}
int FullconnectionInt8CPUKernel::Run() {
auto input_ptr = reinterpret_cast<int8_t *>(in_tensors_[0]->data_c());
auto input_ptr = reinterpret_cast<int8_t *>(in_tensors_.at(0)->data_c());
RowMajor2Row16x4MajorInt8(input_ptr, pack_a_ptr_, fc_param_->row_, fc_param_->deep_);
int32_t tmp_weight_zp = filter_per_channel_ ? 1 : quant_.filter_zp_[0];
CalcInputSums(input_ptr, fc_param_->row_, fc_param_->deep_, tmp_weight_zp, input_sums_, RowMajor);
if (!fc_param_->b_const_) {
auto weight_data = reinterpret_cast<int8_t *>(in_tensors_[1]->data_c());
auto weight_data = reinterpret_cast<int8_t *>(in_tensors_.at(1)->data_c());
RowMajor2Row16x4MajorInt8(weight_data, pack_b_ptr_, fc_param_->col_, fc_param_->deep_);
CalcWeightBiasSums(weight_data, fc_param_->deep_, fc_param_->col_, quant_.input_.zp_, quant_.filter_zp_, bias_ptr_,
weight_bias_sums_, ColMajor, filter_per_channel_);
}
c_ptr_ = reinterpret_cast<int8_t *>(out_tensors_[0]->data_c());
c_ptr_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->data_c());
auto ret = ParallelLaunch(this->context_->thread_pool_, FcInt8Run, this, thread_count_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "ParallelLaunch failed";

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

@ -77,11 +77,11 @@ int GatherNdInt8CPUKernel::ReSize() {
auto in_shape = in_tensors_.front()->shape();
int in_rank = in_shape.size();
int idx_lastshape = indices_shape[indices_rank - 1];
int idx_lastshape = indices_shape.at(indices_rank - 1);
auto indices_ptr = reinterpret_cast<int8_t *>(indices_tensor->MutableData());
area_ = 1;
for (int i = idx_lastshape; i < in_rank; ++i) {
area_ *= in_shape[i];
area_ *= in_shape.at(i);
}
std::vector<int> in_stride(in_rank);
in_stride[in_rank - 1] = 1;

6
mindspore/lite/src/runtime/kernel/arm/int8/gather_int8.cc
View File

@ -61,7 +61,7 @@ int GatherInt8CPUKernel::DoGather(int task_id) {
int in_rank = in_shape.size();
int indices_element_size = indices_tensor->ElementsNum();
const int limit = in_shape[axis_];
const int limit = in_shape.at(axis_);
for (int i = 0; i < indices_element_size; ++i) {
if (indices_ptr[i] >= limit) {
MS_LOG(ERROR) << " indice data: " << indices_ptr[i] << " is not in [ 0, " << limit - 1 << " ]";
@ -71,12 +71,12 @@ int GatherInt8CPUKernel::DoGather(int task_id) {
int outer_size = 1;
for (int i = 0; i < axis_; ++i) {
outer_size *= in_shape[i];
outer_size *= in_shape.at(i);
}
int inner_size = 1;
for (int i = axis_ + 1; i < in_rank; ++i) {
inner_size *= in_shape[i];
inner_size *= in_shape.at(i);
}
int stride = UP_DIV(outer_size, thread_count_);

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

@ -89,9 +89,9 @@ int LayerNormInt8CPUKernel::ReSize() {
inner_size_ = 1;
for (size_t i = 0; i < shape.size(); ++i) {
if (i + param_->normalized_dims_ < shape.size()) {
outer_size_ *= shape[i];
outer_size_ *= shape.at(i);
} else {
inner_size_ *= shape[i];
inner_size_ *= shape.at(i);
}
}

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

@ -85,7 +85,7 @@ int LeakyReluInt8CPUKernel::ReSize() {
auto *out_tensor = out_tensors_.at(kOutputIndex);
auto input_dim = input_tensor->shape().size();
quant_prelu_parm_.input_dim_ = input_dim;
quant_prelu_parm_.element_num = in_tensors_[0]->Size();
quant_prelu_parm_.element_num = in_tensors_.at(0)->Size();
auto input_shape = input_tensor->shape();
if (quant_prelu_parm_.in_shape_ != nullptr) {
free(quant_prelu_parm_.in_shape_);

22
mindspore/lite/src/runtime/kernel/arm/int8/matmul_int8.cc
View File

@ -39,12 +39,14 @@ int MatmulInt8CPUKernel::Init() {
int MatmulInt8CPUKernel::ReSize() {
FreeTmpBuffer();
int batch = 1;
auto x_shape = in_tensors_[0]->shape();
auto o_shape = out_tensors_[0]->shape();
auto x_shape = in_tensors_.at(0)->shape();
auto o_shape = out_tensors_.at(0)->shape();
MS_ASSERT(x_shape.size() >= 2);
for (size_t i = 0; i < x_shape.size() - 2; ++i) {
batch *= x_shape[i];
}
params_->batch = batch;
MS_ASSERT(o_shape.size() >= 2);
params_->row_ = o_shape[o_shape.size() - 2];
params_->col_ = o_shape[o_shape.size() - 1];
params_->deep_ = params_->a_transpose_ ? x_shape[x_shape.size() - 2] : x_shape[x_shape.size() - 1];
@ -77,25 +79,25 @@ int MatmulInt8CPUKernel::ReSize() {
thread_count_ = MSMIN(thread_count_, UP_DIV(params_->col_4_, 4));
thread_stride_ = UP_DIV(UP_DIV(params_->col_4_, 4), thread_count_);
auto input_tensor = in_tensors_[0];
auto input_tensor = in_tensors_.at(0);
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];
auto weight_tensor = in_tensors_.at(1);
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];
auto output_tensor = out_tensors_.at(0);
params = output_tensor->quant_params();
MS_ASSERT(params.size() == 1);
quant_params_.output.zp_ = params.front().zeroPoint;
quant_params_.output.scale_ = params.front().scale;
params_->b_const_ = (in_tensors_[1]->data_c() != nullptr);
params_->b_const_ = (in_tensors_.at(1)->data_c() != nullptr);
if (params_->b_const_) {
auto b_ptr = reinterpret_cast<int8_t *>(in_tensors_[1]->data_c());
auto b_ptr = reinterpret_cast<int8_t *>(in_tensors_.at(1)->data_c());
for (int i = 0; i < params_->batch; ++i) {
auto cur_b = b_ptr + i * params_->deep_ * params_->col_;
auto cur_b_pack = b_c16x4_batch_ + i * params_->col_4_ * params_->deep_16_;
@ -152,14 +154,14 @@ int MatmulInt8Run(void *cdata, int task_id) {
}
int MatmulInt8CPUKernel::Run() {
auto a_ptr = reinterpret_cast<int8_t *>(in_tensors_[0]->data_c());
auto c_ptr = reinterpret_cast<int8_t *>(out_tensors_[0]->data_c());
auto a_ptr = reinterpret_cast<int8_t *>(in_tensors_.at(0)->data_c());
auto c_ptr = reinterpret_cast<int8_t *>(out_tensors_.at(0)->data_c());
auto a_stride = params_->row_ * params_->deep_;
auto b_stride = params_->deep_ * params_->col_;
auto c_stride = params_->row_ * params_->col_;
if (!params_->b_const_) {
auto b_ptr = reinterpret_cast<int8_t *>(in_tensors_[1]->data_c());
auto b_ptr = reinterpret_cast<int8_t *>(in_tensors_.at(1)->data_c());
for (int i = 0; i < params_->batch; ++i) {
auto cur_b = b_ptr + i * b_stride;
auto cur_b_pack = b_c16x4_batch_ + i * params_->col_4_ * params_->deep_16_;

8
mindspore/lite/src/runtime/kernel/arm/int8/pad_int8.cc
View File

@ -87,8 +87,8 @@ int PadInt8CPUKernel::SetQuantParam() {
}
int PadInt8CPUKernel::InitPadParam() {
auto in_dims = in_tensors_[0]->shape();
auto out_dims = out_tensors_[0]->shape();
auto in_dims = in_tensors_.at(0)->shape();
auto out_dims = out_tensors_.at(0)->shape();
int ndims = in_dims.size();
int in[] = {1, 1, 1, 1};
@ -265,8 +265,8 @@ int PadInt8CPUKernel::CopyPaddingFromInput() {
}
int PadInt8CPUKernel::Run() {
in_data_ = reinterpret_cast<int8_t *>(in_tensors_[0]->MutableData());
out_data_ = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
in_data_ = reinterpret_cast<int8_t *>(in_tensors_.at(0)->MutableData());
out_data_ = reinterpret_cast<int8_t *>(out_tensors_.at(0)->MutableData());
int error_code;
if (pad_param_->pad_mode_ == static_cast<int>(schema::PaddingMode_CONSTANT)) {

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

@ -66,7 +66,7 @@ int PowerInt8CPUKernel::DoPower(int task_id) {
int8_t *output_data = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
MS_ASSERT(output_data);
auto size = in_tensors_[0]->ElementsNum();
auto size = in_tensors_.at(0)->ElementsNum();
int stride = UP_DIV(size, op_parameter_->thread_num_);
int count = MSMIN(stride, size - stride * task_id);
int8_t *exp_ptr = nullptr;