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

fix static checking issues of lite ops

This commit is contained in:
liuwenhao4 2020-12-01 16:57:11 +08:00
parent acdcd32fb7
commit e444a03af8
105 changed files with 562 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
mindspore/lite/nnacl/fp16/transpose_fp16.h
View File

@ -23,12 +23,17 @@
#endif
typedef struct TransposeParameter {
// primitive parameter
OpParameter op_parameter_;
int perm_[8];
bool conjugate_;
int num_axes_;
// shape correlative
int strides_[8];
int out_strides_[8];
// other parameter
int num_axes_;
int data_size_;
} TransposeParameter;

11
mindspore/lite/nnacl/fp32/roi_pooling_fp32.h
View File

@ -19,10 +19,15 @@
#include "nnacl/op_base.h"
typedef struct ROIPoolingParameter {
// primitive parameter
OpParameter op_parameter_;
int pooledW_;
int pooledH_;
float scale_;
// shape correlative
int in_strides_[DIMENSION_4D];
int out_strides_[DIMENSION_4D];
float scale_;
int ndim_;
int input_w_;
int input_h_;
@ -32,9 +37,9 @@ typedef struct ROIPoolingParameter {
int output_h_;
int output_n_;
int output_c_;
// other parameter
int thread_num_;
int pooledW_;
int pooledH_;
} ROIPoolingParameter;
#ifdef __cplusplus

7
mindspore/lite/nnacl/fp32/skip_gram_fp32.h
View File

@ -19,11 +19,12 @@
#include "nnacl/op_base.h"
typedef struct {
typedef struct SkipGramParameter {
// primitive parameter
OpParameter op_parameter_;
int ngram_size;
int max_skip_size;
bool include_all_ngrams;
int max_skip_size;
int ngram_size;
} SkipGramParameter;
#endif // MINDSPORE_LITE_NNACL_FP32_SKIP_GRAM_H_

9
mindspore/lite/nnacl/fp32/space_to_batch_fp32.h
View File

@ -18,16 +18,21 @@
#include "nnacl/op_base.h"
typedef struct SpaceToBatchParameter {
// primitive parameter
OpParameter op_parameter_;
bool need_paddings_;
int m_;
int block_sizes_[4];
int paddings_[4];
// shape correlative
int input_shape_[4];
int output_shape_[4];
int in_stride_[4];
int out_stride_[4];
int padded_in_shape_[4];
// other parameter
bool need_paddings_;
int m_;
} SpaceToBatchParameter;
#ifdef __cplusplus
extern "C" {

1
mindspore/lite/nnacl/fp32/space_to_depth_fp32.h
View File

@ -18,6 +18,7 @@
#include "nnacl/op_base.h"
typedef struct SpaceToDepthParameter {
// primitive parameter
OpParameter op_parameter_;
int32_t block_size_;
} SpaceToDepthParameter;

11
mindspore/lite/nnacl/fp32/tile_fp32.h
View File

@ -20,14 +20,19 @@
#include "nnacl/op_base.h"
typedef struct TileParameter {
// primitive parameter
OpParameter op_parameter_;
int in_dim_;
int multiples_[5];
int dims_[5];
// shape correlative
int in_shape_[5];
int out_shape_[5];
int dims_[5];
int multiples_[5];
int in_strides_[5];
int out_strides_[5];
// other parameter
int in_dim_;
} TileParameter;
#ifdef __cplusplus

7
mindspore/lite/nnacl/fp32/topk_fp32.h
View File

@ -25,11 +25,14 @@ typedef struct TopkNode {
} TopkNode;
typedef struct TopkParameter {
// primitive parameter
OpParameter op_parameter_;
int last_dim_size_;
int loop_num_;
int k_;
bool sorted_;
// other parameter
int last_dim_size_;
int loop_num_;
void *topk_node_list_;
} TopkParameter;

1
mindspore/lite/nnacl/fp32/unique_fp32.h
View File

@ -20,6 +20,7 @@
#include "nnacl/op_base.h"
typedef struct UniqueParameter {
// primitive parameter
OpParameter op_parameter_;
} UniqueParameter;

3
mindspore/lite/nnacl/fp32/unsqueeze_fp32.h
View File

@ -22,8 +22,11 @@
#define UNSQUEEZE_DIMS_MAX_SIZE 4
typedef struct UnsqueezeParameter {
// primitive parameter
OpParameter op_parameter_;
int dims_[UNSQUEEZE_DIMS_MAX_SIZE];
// other parameter
int num_dim_;
} UnsqueezeParameter;

9
mindspore/lite/nnacl/fp32_grad/softmax_grad.h
View File

@ -25,11 +25,16 @@ extern "C" {
#endif
typedef struct SoftmaxCrossEntropyParameter {
// primitive parameter
OpParameter op_parameter_;
int n_dim_;
// shape correlative
int input_shape_[5];
// other parameter
int32_t batch_size_;
unsigned int number_of_classes_;
int n_dim_;
int input_shape_[5];
int is_grad;
} SoftmaxCrossEntropyParameter;

7
mindspore/lite/nnacl/reduce_parameter.h
View File

@ -20,13 +20,16 @@
#define REDUCE_MAX_AXES_NUM 8
typedef struct ReduceParameter {
// primitive parameter
OpParameter op_parameter_;
int axes_[REDUCE_MAX_AXES_NUM];
bool keep_dims_;
int mode_;
bool reduce_to_end_;
float coeff;
int axes_[REDUCE_MAX_AXES_NUM];
// other parameter
int num_axes_;
int mode_;
} ReduceParameter;
#endif // MINDSPORE_LITE_NNACL_REDUCE_PARAMETER_H_

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

@ -21,7 +21,10 @@
#include "nnacl/quantization/quantize.h"
typedef struct ReshapeParameter {
// primitive parameter
OpParameter op_parameter_;
// other parameter
ReshapeQuantArg quant_para_;
int thread_count_;
} ReshapeParameter;

1
mindspore/lite/nnacl/resize_parameter.h
View File

@ -18,6 +18,7 @@
#include "nnacl/op_base.h"
typedef struct ResizeParameter {
// primitive parameter
OpParameter op_parameter_;
int method_;
int64_t new_height_;

11
mindspore/lite/nnacl/reverse_sequence.h
View File

@ -20,14 +20,19 @@
#include "nnacl/op_base.h"
typedef struct ReverseSequenceParameter {
// primitive parameter
OpParameter op_parameter_;
int ndim_;
int seq_axis_;
int batch_axis_;
// shape correlative
int input_shape0_[5];
int output_shape_[5];
int input_stride_[5];
int output_stride_[5];
int seq_axis_;
int batch_axis_;
// other parameter
int ndim_;
int outer_count_;
int outer_stride_;
int inner_count_;

9
mindspore/lite/nnacl/scale.h
View File

@ -20,11 +20,17 @@
#include <mindspore/lite/nnacl/quantization/quantize.h>
#include "nnacl/op_base.h"
typedef struct ScaleParameter {
// primitive parameter
OpParameter op_parameter_;
int axis_;
int activation_type_;
// shape correlative
int outer_size_;
int axis_size_;
int inner_size_;
int axis_;
// other parameter
bool const_scale_;
bool const_offset_;
QuantMulArg scale_mul_arg_;
@ -33,7 +39,6 @@ typedef struct ScaleParameter {
int scale_zp_;
int offset_zp_;
int output_zp_;
int activation_type_;
int output_activation_min_;
int output_activation_max_;
} ScaleParameter;

1
mindspore/lite/nnacl/scatter_nd.h
View File

@ -20,6 +20,7 @@
#include "nnacl/op_base.h"
typedef struct ScatterNDParameter {
// primitive parameter
OpParameter op_parameter_;
} ScatterNDParameter;

1
mindspore/lite/nnacl/shape.h
View File

@ -20,6 +20,7 @@
#include "nnacl/op_base.h"
typedef struct ShapeParameter {
// primitive parameter
OpParameter op_parameter_;
} ShapeParameter;

9
mindspore/lite/nnacl/sigmoid_parameter.h
View File

@ -21,15 +21,20 @@
#define SIGMOID_OFFSET_MAX_SIZE 4
typedef struct SigmoidParameter {
// primitive parameter
OpParameter op_parameter_;
// shape correlative
const int *in_shape_;
const int *out_shape_;
// other parameter
SigmoidQuantArg quant_arg;
double alpha_;
int thread_count_;
int64_t offset_[PRELU_OFFSET_MAX_SIZE];
int64_t in_offset_[PRELU_OFFSET_MAX_SIZE];
int64_t axis_;
const int *in_shape_;
const int *out_shape_;
int input_dim_;
int element_num;
} SigmoidParameter;

9
mindspore/lite/nnacl/slice_parameter.h
View File

@ -23,12 +23,17 @@
#define SLICE_SHAPE_MAX_SIZE 4
typedef struct SliceParameter {
// primitive parameter
OpParameter op_parameter_;
SliceQuantArg quant_arg_;
// shape correlative
int32_t shape_[SLICE_SHAPE_MAX_SIZE];
int32_t begin_[SLICE_SHAPE_MAX_SIZE];
int32_t end_[SLICE_SHAPE_MAX_SIZE];
int32_t size_[SLICE_SHAPE_MAX_SIZE];
int32_t shape_[SLICE_SHAPE_MAX_SIZE];
// other parameter
SliceQuantArg quant_arg_;
int32_t param_length_;
} SliceParameter;

7
mindspore/lite/nnacl/softmax_parameter.h
View File

@ -20,11 +20,16 @@
#include "nnacl/op_base.h"
typedef struct SoftmaxParameter {
// primitive parameter
OpParameter op_parameter_;
int32_t axis_;
// shape correlative
int input_shape_[5];
// other parameter
int element_size_;
int n_dim_;
int input_shape_[5];
} SoftmaxParameter;
#endif // MINDSPORE_LITE_NNACL_SOFTMAX_PARAMETER_H_

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

@ -20,8 +20,11 @@
#include "nnacl/op_base.h"
typedef struct SparseToDenseParameter {
// primitive parameter
OpParameter op_parameter_;
bool validate_indices_;
// other parameter
int thread_num_;
} SparseToDenseParameter;

9
mindspore/lite/nnacl/split_parameter.h
View File

@ -21,12 +21,17 @@
#include "nnacl/quantization/quantize.h"
#define SPLIT_STRIDES_SIZE 32
typedef struct SplitParameter {
// primitive parameter
OpParameter op_parameter_;
SplitQuantArg quant_arg_;
int num_split_;
int *split_sizes_;
int strides_[SPLIT_STRIDES_SIZE];
int split_dim_;
// shape correlative
int strides_[SPLIT_STRIDES_SIZE];
// other parameter
SplitQuantArg quant_arg_;
int n_dims_;
int split_count_;
} SplitParameter;

1
mindspore/lite/nnacl/squeeze.h
View File

@ -20,6 +20,7 @@
#include "nnacl/op_base.h"
typedef struct SqueezeParameter {
// primitive parameter
OpParameter op_parameter_;
int axes_[8];
} SqueezeParameter;

17
mindspore/lite/nnacl/squeeze_parameter.h
View File

@ -22,17 +22,22 @@
#define SQUEEZE_OFFSET_MAX_SIZE 4
typedef struct SqueezeParameter {
// primitive parameter
OpParameter op_parameter_;
SqueezeQuantArg quant_arg;
int thread_count_;
int thread_id_;
int64_t axis_;
// shape correlative
const int *in_shape_;
const int *out_shape_;
int offset_size_;
int64_t offset_[SQUEEZE_OFFSET_MAX_SIZE];
int64_t in_offset_[SQUEEZE_OFFSET_MAX_SIZE];
int64_t axis_;
const int *in_shape_;
const int *out_shape_;
int input_dim_;
// other parameter
SqueezeQuantArg quant_arg;
int thread_count_;
int thread_id_;
} SqueezeParameter;
#endif // MINDSPORE_LITE_NNACL_SQUEEZE_PARAMETER_H_

1
mindspore/lite/nnacl/stack_parameter.h
View File

@ -19,6 +19,7 @@
#include "nnacl/op_base.h"
typedef struct StackParameter {
// primitive parameter
OpParameter op_parameter_;
int32_t axis_;
} StackParameter;

7
mindspore/lite/nnacl/strided_slice.h
View File

@ -19,14 +19,19 @@
#include "nnacl/op_base.h"
typedef struct StridedSliceParameter {
// primitive parameter
OpParameter op_parameter_;
int begins_[8];
int ends_[8];
int strides_[8];
int isScale;
int num_axes_;
// shape correlative
int in_shape_length_;
int in_shape_[8];
// other parameter
int num_axes_;
LiteDataType data_type;
} StridedSliceParameter;

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

@ -21,9 +21,12 @@
#include "ir/dtype/type_id.h"
typedef struct TensorListParameter {
// primitive parameter
OpParameter op_parameter_;
mindspore::TypeId shape_type_;
mindspore::TypeId element_dtype_;
// other parameter
int num_element_;
} TensorListParameter;

7
mindspore/lite/nnacl/transpose.h
View File

@ -22,12 +22,17 @@
#define MAX_TRANSPOSE_DIM_SIZE 5
typedef struct TransposeParameter {
// primitive parameter
OpParameter op_parameter_;
int perm_[8];
bool conjugate_;
int num_axes_;
// shape correlative
int strides_[8];
int out_strides_[8];
// other parameter
int num_axes_;
int data_size_;
} TransposeParameter;

17
mindspore/lite/nnacl/unsqueeze_parameter.h
View File

@ -22,17 +22,22 @@
#define UNSQUEEZE_OFFSET_MAX_SIZE 4
typedef struct UnSqueezeParameter {
// primitive parameter
OpParameter op_parameter_;
int64_t axis_;
// shape correlative
const int *in_shape_;
const int *out_shape_;
int input_dim_;
int64_t offset_[UNSQUEEZE_OFFSET_MAX_SIZE];
int64_t in_offset_[UNSQUEEZE_OFFSET_MAX_SIZE];
// other parameter
UnSqueezeQuantArg quant_arg;
int thread_count_;
int thread_id_;
int offset_size_;
int64_t offset_[UNSQUEEZE_OFFSET_MAX_SIZE];
int64_t in_offset_[UNSQUEEZE_OFFSET_MAX_SIZE];
int64_t axis_;
const int *in_shape_;
const int *out_shape_;
int input_dim_;
} UnSqueezeParameter;
#endif // MINDSPORE_LITE_NNACL_UNSQUEEZE_PARAMETER_H_

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

@ -20,9 +20,12 @@
#include "nnacl/op_base.h"
typedef struct UnstackParameter {
// primitive parameter
OpParameter op_parameter_;
int num_;
int axis_;
// other parameter
int pre_dims_;
int axis_dim_;
int after_dims_;

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

@ -19,7 +19,10 @@
#include "nnacl/op_base.h"
typedef struct {
// primitive parameter
OpParameter op_parameter_;
// other parameter
int method_; // 0 for bilinear; 1 for nearest
} UpsampleParameter;

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

@ -19,7 +19,10 @@
#include "nnacl/op_base.h"
typedef struct WhereParameter {
// primitive parameter
OpParameter op_parameter_;
// other parameter
int num_;
int num1_;
int num2_;

4
mindspore/lite/src/ops/populate/slice_populate.cc
View File

@ -41,8 +41,8 @@ OpParameter *PopulateSliceParameter(const mindspore::lite::PrimitiveC *primitive
}
slice_param->param_length_ = static_cast<int32_t>(param_begin.size());
for (int32_t i = 0; i < slice_param->param_length_; ++i) {
slice_param->begin_[i] = param_begin[i];
slice_param->size_[i] = param_size[i];
slice_param->begin_[i] = param_begin.at(i);
slice_param->size_[i] = param_size.at(i);
}
return reinterpret_cast<OpParameter *>(slice_param);
}

8
mindspore/lite/src/ops/populate/space_to_batch_nd_populate.cc
View File

@ -32,8 +32,16 @@ OpParameter *PopulateSpaceToBatchNDParameter(const mindspore::lite::PrimitiveC *
space_batch_param_nd->op_parameter_.type_ = primitive->Type();
auto block_sizes = ((mindspore::lite::SpaceToBatchND *)primitive)->GetBlockShape();
space_batch_param_nd->m_ = block_sizes.size();
if (block_sizes.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of block_sizes.size() is too big";
return nullptr;
}
memcpy(space_batch_param_nd->block_sizes_, (block_sizes.data()), block_sizes.size() * sizeof(int));
auto paddings = ((mindspore::lite::SpaceToBatchND *)primitive)->GetPaddings();
if (paddings.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of paddings.size() is too big";
return nullptr;
}
memcpy(space_batch_param_nd->paddings_, (paddings.data()), paddings.size() * sizeof(int));
return reinterpret_cast<OpParameter *>(space_batch_param_nd);
}

8
mindspore/lite/src/ops/populate/space_to_batch_populate.cc
View File

@ -34,8 +34,16 @@ OpParameter *PopulateSpaceToBatchParameter(const mindspore::lite::PrimitiveC *pr
space_batch_param->op_parameter_.type_ = primitive->Type();
auto block_sizes = ((mindspore::lite::SpaceToBatch *)primitive)->BlockSizes();
space_batch_param->m_ = block_sizes.size();
if (block_sizes.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of block_sizes.size() is too big";
return nullptr;
}
memcpy(space_batch_param->block_sizes_, (block_sizes.data()), block_sizes.size() * sizeof(int));
auto paddings = ((mindspore::lite::SpaceToBatch *)primitive)->Paddings();
if (paddings.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of paddings.size() is too big";
return nullptr;
}
memcpy(space_batch_param->paddings_, (paddings.data()), paddings.size() * sizeof(int));
return reinterpret_cast<OpParameter *>(space_batch_param);
}

4
mindspore/lite/src/ops/populate/split_populate.cc
View File

@ -32,6 +32,10 @@ OpParameter *PopulateSplitParameter(const mindspore::lite::PrimitiveC *primitive
auto param = reinterpret_cast<mindspore::lite::Split *>(const_cast<mindspore::lite::PrimitiveC *>(primitive));
split_param->op_parameter_.type_ = primitive->Type();
split_param->num_split_ = param->GetNumberSplit();
if (split_param->num_split_ > std::numeric_limits<int>::max() / static_cast<int>(sizeof(int))) {
MS_LOG(ERROR) << "The value of split_param->num_split_ is too big";
return nullptr;
}
int *split_sizes = reinterpret_cast<int *>(malloc(split_param->num_split_ * sizeof(int)));
if (split_sizes == nullptr) {
MS_LOG(ERROR) << "malloc split size of SplitParameter failed.";

16
mindspore/lite/src/ops/populate/strided_slice_populate.cc
View File

@ -35,12 +35,28 @@ OpParameter *PopulateStridedSliceParameter(const mindspore::lite::PrimitiveC *pr
auto n_dims = ((lite::StridedSlice *)primitive)->NDims();
strided_slice_param->num_axes_ = n_dims;
auto begin = ((lite::StridedSlice *)primitive)->GetBegins();
if (begin.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of begin.size() is too big";
return nullptr;
}
memcpy(strided_slice_param->begins_, (begin.data()), begin.size() * sizeof(int));
auto end = ((lite::StridedSlice *)primitive)->GetEnds();
if (end.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of end.size() is too big";
return nullptr;
}
memcpy(strided_slice_param->ends_, (end.data()), end.size() * sizeof(int));
auto stride = ((lite::StridedSlice *)primitive)->GetStrides();
if (stride.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of stride.size() is too big";
return nullptr;
}
memcpy(strided_slice_param->strides_, (stride.data()), stride.size() * sizeof(int));
auto in_shape = ((lite::StridedSlice *)primitive)->GetInShape();
if (in_shape.size() > std::numeric_limits<size_t>::max() / sizeof(int)) {
MS_LOG(ERROR) << "The value of in_shape.size() is too big";
return nullptr;
}
memcpy(strided_slice_param->in_shape_, (in_shape.data()), in_shape.size() * sizeof(int));
strided_slice_param->in_shape_length_ = static_cast<int>(in_shape.size());
return reinterpret_cast<OpParameter *>(strided_slice_param);

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

@ -44,7 +44,7 @@ OpParameter *PopulateTileParameter(const mindspore::lite::PrimitiveC *primitive)
tile_param->multiples_[i] = 1;
}
for (size_t i = 0; i < dims.size(); ++i) {
tile_param->multiples_[dims[i]] = multiples[i];
tile_param->multiples_[dims.at(i)] = multiples.at(i);
}
#endif
return reinterpret_cast<OpParameter *>(tile_param);

9
mindspore/lite/src/ops/reduce.cc
View File

@ -76,7 +76,7 @@ int Reduce::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inp
attr->keepDims = GetValue<bool>(prim.GetAttr("keep_dims"));
if (inputs.size() == kAnfPopulaterInputNumTwo) {
auto inputNode = inputs[kAnfPopulaterInputNumOne];
auto inputNode = inputs.at(kAnfPopulaterInputNumOne);
MS_ASSERT(inputNode != nullptr);
if (inputNode->isa<ValueNode>()) {
auto valueNode = inputNode->cast<ValueNodePtr>();
@ -178,7 +178,7 @@ int Reduce::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
}
int begin_axis;
begin_axis = axes[0] < 0 ? axes[0] + rank : axes[0];
begin_axis = axes.at(0) < 0 ? axes.at(0) + rank : axes.at(0);
for (auto i = begin_axis + 1; i < rank; ++i) {
actual_axes.emplace_back(i);
}
@ -200,7 +200,8 @@ int Reduce::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
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>(actual_axes[idx]) == i || static_cast<size_t>(actual_axes[idx] + in_shape.size()) == i) {
if (static_cast<size_t>(actual_axes.at(idx)) == i ||
static_cast<size_t>(actual_axes.at(idx) + in_shape.size()) == i) {
reduce_axis = true;
break;
}
@ -210,7 +211,7 @@ int Reduce::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
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);

12
mindspore/lite/src/ops/reshape.cc
View File

@ -48,7 +48,7 @@ int Reshape::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &in
if (this->primitive_->value.value == nullptr) {
auto attr = new (std::nothrow) schema::ReshapeT();
MS_ASSERT(inputs.size() == kAnfPopulaterInputNumThree - 1);
auto inputNode = inputs[kAnfPopulaterInputNumTwo - 1];
auto inputNode = inputs.at(kAnfPopulaterInputNumTwo - 1);
if (inputNode->isa<ValueNode>()) {
auto valueNode = inputNode->cast<ValueNodePtr>();
MS_ASSERT(valueNode != nullptr);
@ -58,7 +58,7 @@ int Reshape::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &in
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);
attr->shape.emplace_back(CastToInt(elem).front());
}
@ -114,7 +114,7 @@ Registry ReshapeRegistry(schema::PrimitiveType_Reshape, ReshapeCreator);
int Reshape::CalNewShape(const Tensor *in_tensor, std::vector<int> *out_shape) const {
size_t in_shape_size = 1;
for (size_t i = 0; i < in_tensor->shape().size(); i++) {
in_shape_size *= in_tensor->shape()[i];
in_shape_size *= in_tensor->shape().at(i);
}
int64_t inferIndex = -1;
size_t out_shapeSize = 1;
@ -154,14 +154,14 @@ void CalShape(const T *data, const std::vector<Tensor *> &inputs, std::vector<in
if (static_cast<int>(data[i]) == -1) {
index = i;
} else if (static_cast<int>(data[i]) == 0) {
size *= inputs[0]->shape()[i];
size *= inputs[0]->shape().at(i);
} else {
size *= data[i];
}
out_shape->push_back(data[i]);
}
if (static_cast<int>(data[index]) == -1) {
(*out_shape)[index] = input_count / size;
(*out_shape).at(index) = input_count / size;
}
}
int Reshape::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
@ -219,7 +219,7 @@ int Reshape::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> out
}
} else if (inputs_.size() == kSingleNum) {
for (size_t i = 0; i < GetShape().size(); ++i) {
out_shape.push_back(GetShape()[i]);
out_shape.push_back(GetShape().at(i));
}
} else {
MS_LOG(ERROR) << "inputs tensor size invalid.";

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

@ -68,8 +68,8 @@ int Resize::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inp
return RET_ERROR;
}
std::vector<int> targetSize = CastToInt(prim.GetAttr("size"));
attr->newHeight = targetSize[0];
attr->newWidth = targetSize[1];
attr->newHeight = targetSize.at(0);
attr->newWidth = targetSize.at(1);
attr->alignCorners = GetValue<bool>(prim.GetAttr("align_corners"));
this->primitive_->value.value = attr;

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

@ -57,7 +57,7 @@ int Rfft::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
return RET_OK;
}
auto input_shape = input->shape();
input_shape[input_shape.size() - 1] = GetFftLength() / 2 + 1;
input_shape.at(input_shape.size() - 1) = GetFftLength() / 2 + 1;
input_shape.push_back(2);
outputs_.front()->set_shape(input_shape);
return RET_OK;

9
mindspore/lite/src/ops/sgd.cc
View File

@ -86,16 +86,17 @@ int Sgd::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tensor
return RET_ERROR;
}
if (inputs[0]->ElementsNum() != inputs[1]->ElementsNum() || inputs[0]->ElementsNum() != inputs[3]->ElementsNum() ||
inputs[2]->ElementsNum() != 1 || inputs[4]->ElementsNum() != 1) {
if (inputs.at(0)->ElementsNum() != inputs.at(1)->ElementsNum() ||
inputs.at(0)->ElementsNum() != inputs.at(3)->ElementsNum() || inputs.at(2)->ElementsNum() != 1 ||
inputs.at(4)->ElementsNum() != 1) {
MS_LOG(ERROR) << "error input data size!";
return RET_ERROR;
}
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});
}

34
mindspore/lite/src/ops/slice.cc
View File

@ -77,7 +77,7 @@ int Slice::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inpu
}
}
}
auto sizeNode = inputs[kAnfPopulaterInputNumTwo];
auto sizeNode = inputs.at(kAnfPopulaterInputNumTwo);
MS_ASSERT(sizeNode != nullptr);
if (sizeNode->isa<ValueNode>()) {
auto valueNode = sizeNode->cast<ValueNodePtr>();
@ -172,8 +172,8 @@ int Slice::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tens
return RET_PARAM_INVALID;
}
auto input = inputs.at(0);
outputs[0]->set_data_type(input->data_type());
outputs[0]->set_format(input->format());
outputs.at(0)->set_data_type(input->data_type());
outputs.at(0)->set_format(input->format());
if (!infer_flag()) {
return RET_OK;
}
@ -191,7 +191,7 @@ int Slice::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tens
if (slice_size.empty() && inputs.at(2)->data_c() != nullptr) {
for (int i = 0; i < inputs.at(2)->ElementsNum(); i++) {
auto end = static_cast<int *>(inputs.at(2)->data_c())[i];
auto size = end < 0 ? end : (end == INT32_MAX ? -1 : end - slice_begin[i]);
auto size = end < 0 ? end : (end == INT32_MAX ? -1 : end - slice_begin.at(i));
slice_size.emplace_back(size);
}
}
@ -208,32 +208,32 @@ int Slice::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tens
begin.assign(input_shape.size(), 0);
size.assign(input_shape.size(), -1);
for (size_t i = 0; i < slice_axes.size(); ++i) {
begin[slice_axes[i]] = slice_begin[i];
size[slice_axes[i]] = slice_size[i];
begin.at(slice_axes.at(i)) = slice_begin.at(i);
size.at(slice_axes.at(i)) = slice_size.at(i);
}
for (size_t i = 0; i < input_shape.size(); ++i) {
if (size[i] < 0 && size[i] != -1) {
MS_LOG(ERROR) << "Invalid size input!size[" << i << "]=" << size[i];
if (size.at(i) < 0 && size.at(i) != -1) {
MS_LOG(ERROR) << "Invalid size input!size[" << i << "]=" << size.at(i);
return RET_PARAM_INVALID;
}
if (begin[i] < 0) {
MS_LOG(ERROR) << "Invalid begin input " << begin[i] << " which should be >= 0";
if (begin.at(i) < 0) {
MS_LOG(ERROR) << "Invalid begin input " << begin.at(i) << " which should be >= 0";
return RET_PARAM_INVALID;
}
if (input_shape[i] <= begin[i]) {
MS_LOG(ERROR) << "Invalid begin input!begin[" << i << "]=" << begin[i]
<< " which should be <= " << input_shape[i];
if (input_shape.at(i) <= begin.at(i)) {
MS_LOG(ERROR) << "Invalid begin input!begin[" << i << "]=" << begin.at(i)
<< " which should be <= " << input_shape.at(i);
return RET_PARAM_INVALID;
}
if (size[i] > (input_shape[i] - begin[i])) {
MS_LOG(ERROR) << "Invalid size input " << size[i] << " which should be <= " << input_shape[i] - begin[i];
if (size.at(i) > (input_shape.at(i) - begin.at(i))) {
MS_LOG(ERROR) << "Invalid size input " << size.at(i) << " which should be <= " << input_shape.at(i) - begin.at(i);
return RET_PARAM_INVALID;
}
output_shape[i] = size[i] < 0 ? input_shape[i] - begin[i] : size[i];
output_shape.at(i) = size.at(i) < 0 ? input_shape.at(i) - begin.at(i) : size.at(i);
}
outputs[0]->set_shape(output_shape);
outputs.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

32
mindspore/lite/src/ops/space_to_batch_nd.cc
View File

@ -96,8 +96,8 @@ int SpaceToBatchND::InferShape(std::vector<lite::Tensor *> inputs, std::vector<l
MS_LOG(ERROR) << "space_to_batch_nd only support NHWC now!";
return RET_ERROR;
}
outputs[0]->set_data_type(input->data_type());
outputs[0]->set_format(input->format());
outputs.at(0)->set_data_type(input->data_type());
outputs.at(0)->set_format(input->format());
if (!infer_flag()) {
return RET_OK;
}
@ -112,16 +112,28 @@ int SpaceToBatchND::InferShape(std::vector<lite::Tensor *> inputs, std::vector<l
int padding_right = 0;
int block_w = 1;
if (block_shape.size() == 2) {
padding_left = padding[2];
padding_right = padding[3];
block_w = block_shape[1];
padding_left = padding.at(2);
padding_right = padding.at(3);
block_w = block_shape.at(1);
}
std::vector<int32_t> output_shape(input_shape.size());
output_shape[NHWC_N] = input_shape[NHWC_N] * block_shape[0] * block_w;
output_shape[NHWC_H] = (input_shape[NHWC_H] + padding[0] + padding[1]) / block_shape[0];
output_shape[NHWC_W] = (input_shape[NHWC_W] + padding_left + padding_right) / block_w;
output_shape[NHWC_C] = input_shape[NHWC_C];
outputs[0]->set_shape(output_shape);
if (block_shape.at(0) * block_w > std::numeric_limits<int>::max() / input_shape.at(NHWC_N)) {
MS_LOG(ERROR) << "The value of block_shape.at(0) * block_w is too big";
return RET_ERROR;
}
output_shape.at(NHWC_N) = input_shape.at(NHWC_N) * block_shape.at(0) * block_w;
if (padding.at(0) + padding.at(1) > std::numeric_limits<int>::max() - input_shape.at(NHWC_H)) {
MS_LOG(ERROR) << "The value of padding.at(0) + padding.at(1) is too big";
return RET_ERROR;
}
output_shape.at(NHWC_H) = (input_shape.at(NHWC_H) + padding.at(0) + padding.at(1)) / block_shape.at(0);
if (padding_left + padding_right > std::numeric_limits<int>::max() - input_shape.at(NHWC_W)) {
MS_LOG(ERROR) << "The value of padding_left + padding_right is too big";
return RET_ERROR;
}
output_shape.at(NHWC_W) = (input_shape.at(NHWC_W) + padding_left + padding_right) / block_w;
output_shape.at(NHWC_C) = input_shape.at(NHWC_C);
outputs.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

22
mindspore/lite/src/ops/space_to_depth.cc
View File

@ -71,8 +71,8 @@ int SpaceToDepth::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
MS_LOG(ERROR) << "space_to_depth only support NHWC now!";
return 1;
}
outputs[0]->set_format(input->format());
outputs[0]->set_data_type(input->data_type());
outputs.at(0)->set_format(input->format());
outputs.at(0)->set_data_type(input->data_type());
if (!infer_flag()) {
return RET_OK;
}
@ -83,17 +83,21 @@ int SpaceToDepth::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
}
int32_t block_size = GetBlockSize();
if (input_shape[NHWC_H] % block_size != 0 || input_shape[NHWC_H] == 0 || input_shape[NHWC_W] % block_size != 0 ||
input_shape[NHWC_W] == 0) {
if (input_shape.at(NHWC_H) % block_size != 0 || input_shape.at(NHWC_H) == 0 ||
input_shape.at(NHWC_W) % block_size != 0 || input_shape.at(NHWC_W) == 0) {
MS_LOG(ERROR) << "input dimension h or w size error!";
return 1;
}
std::vector<int32_t> output_shape(input_shape.size());
output_shape[NHWC_N] = input_shape[NHWC_N];
output_shape[NHWC_H] = input_shape[NHWC_H] / block_size;
output_shape[NHWC_W] = input_shape[NHWC_W] / block_size;
output_shape[NHWC_C] = input_shape[NHWC_C] * (block_size * block_size);
outputs[0]->set_shape(output_shape);
output_shape.at(NHWC_N) = input_shape.at(NHWC_N);
output_shape.at(NHWC_H) = input_shape.at(NHWC_H) / block_size;
output_shape.at(NHWC_W) = input_shape.at(NHWC_W) / block_size;
if (block_size * block_size > std::numeric_limits<int32_t>::max() / input_shape.at(NHWC_C)) {
MS_LOG(ERROR) << "The value of block_size * block_size is too big";
return RET_ERROR;
}
output_shape.at(NHWC_C) = input_shape.at(NHWC_C) * (block_size * block_size);
outputs.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

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

@ -51,8 +51,8 @@ int SparseToDense::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor
return RET_ERROR;
}
auto input2 = inputs_.at(2);
outputs_[0]->set_data_type(input2->data_type());
outputs_[0]->set_format(input2->format());
outputs_.at(0)->set_data_type(input2->data_type());
outputs_.at(0)->set_format(input2->format());
if (!infer_flag()) {
return RET_OK;
@ -67,7 +67,7 @@ int SparseToDense::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor
for (int i = 0; i < input1->ElementsNum(); i++) {
output_shape.push_back(input1_data[i]);
}
outputs_[0]->set_shape(output_shape);
outputs_.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

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

@ -119,8 +119,8 @@ int Split::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outpu
return RET_ERROR;
}
for (int i = 0; i < number_split; ++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;
@ -129,26 +129,26 @@ int Split::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outpu
std::vector<int> input_shape = input->shape();
std::vector<int> size_split;
for (size_t i = 0; i < GetSizeSplits().size(); ++i) {
size_split.push_back(GetSizeSplits()[i]);
size_split.push_back(GetSizeSplits().at(i));
}
for (int i = 0; i < number_split; ++i) {
std::vector<int> output_shape;
output_shape.insert(output_shape.begin(), input_shape.begin(), input_shape.end());
int split_dim_i = input_shape[split_dim];
int split_dim_i = input_shape.at(split_dim);
// support split size is -1 in the end.
if (size_split.empty()) {
split_dim_i = input_shape[split_dim] / number_split;
} else if (i == number_split - 1 && size_split[i] == -1) {
split_dim_i = input_shape.at(split_dim) / number_split;
} else if (i == number_split - 1 && size_split.at(i) == -1) {
for (size_t j = 0; j < size_split.size() - 1; ++j) {
split_dim_i -= size_split[j];
split_dim_i -= size_split.at(j);
}
} else {
split_dim_i = size_split[i];
split_dim_i = size_split.at(i);
}
output_shape[split_dim] = split_dim_i;
outputs_[i]->set_shape(output_shape);
outputs_[i]->set_data_type(input->data_type());
outputs_[i]->set_format(input->format());
output_shape.at(split_dim) = split_dim_i;
outputs_.at(i)->set_shape(output_shape);
outputs_.at(i)->set_data_type(input->data_type());
outputs_.at(i)->set_format(input->format());
}
return RET_OK;
}

10
mindspore/lite/src/ops/squeeze.cc
View File

@ -117,19 +117,19 @@ int Squeeze::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> out
}
if (axes_.size() == 0) {
for (size_t i = 0; i < in_shape.size(); i++) {
if (in_shape[i] != 1) {
out_shape.push_back(in_shape[i]);
if (in_shape.at(i) != 1) {
out_shape.push_back(in_shape.at(i));
}
}
} else {
size_t axisIdx = 0;
for (size_t i = 0; i < in_shape.size(); i++) {
if (axisIdx < axes_.size() && axes_[axisIdx] == static_cast<int>(i)) {
MS_ASSERT(in_shape[i] == 1);
if (axisIdx < axes_.size() && axes_.at(axisIdx) == static_cast<int>(i)) {
MS_ASSERT(in_shape.at(i) == 1);
axisIdx++;
continue;
} else {
out_shape.push_back(in_shape[i]);
out_shape.push_back(in_shape.at(i));
}
}
}

14
mindspore/lite/src/ops/stack.cc
View File

@ -80,8 +80,8 @@ int Stack::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> output
}
auto input = inputs.at(0);
auto input0_data_type = input->data_type();
outputs[0]->set_data_type(input0_data_type);
outputs[0]->set_format(input->format());
outputs.at(0)->set_data_type(input0_data_type);
outputs.at(0)->set_format(input->format());
if (!infer_flag()) {
return RET_OK;
}
@ -95,25 +95,25 @@ int Stack::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> output
}
for (size_t i = 1; i < inputs.size(); ++i) {
auto input_shape_tmp = inputs[i]->shape();
auto input_shape_tmp = inputs.at(i)->shape();
if (input_shape_tmp.size() != input_shape.size()) {
MS_LOG(ERROR) << "All input shape size should be the same!";
return RET_PARAM_INVALID;
}
for (size_t j = 0; j < input_shape.size(); ++j) {
if (input_shape_tmp[j] != input_shape[j]) {
if (input_shape_tmp.at(j) != input_shape.at(j)) {
MS_LOG(ERROR) << "All input shape should be the same!";
return RET_PARAM_INVALID;
}
}
if (inputs[i]->data_type() != input0_data_type) {
if (inputs.at(i)->data_type() != input0_data_type) {
MS_LOG(ERROR) << "All input shuld have the same data type!input[" << i
<< "] data type = " << inputs[i]->data_type();
<< "] data type = " << inputs.at(i)->data_type();
return RET_PARAM_INVALID;
}
}
output_shape.insert(output_shape.begin() + axis, inputs.size());
outputs[0]->set_shape(output_shape);
outputs.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

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

@ -179,7 +179,7 @@ constexpr size_t kStridedSliceMultiInputNumMax = 5;
} // namespace
bool StridedSlice::CheckInputs(std::vector<lite::Tensor *> inputs_) {
for (size_t i = 1; i < inputs_.size(); ++i) {
if (inputs_[i]->data_c() == nullptr) {
if (inputs_.at(i)->data_c() == nullptr) {
MS_LOG(DEBUG) << "strided_slice has input from other node, which only can be obtained when running.";
return false;
}
@ -309,8 +309,8 @@ int StridedSlice::HandleAxesInputExist(const std::vector<lite::Tensor *> &inputs
} else {
axes.assign(axes_data, axes_data + begin_ndim);
for (int i = 0; i < begin_ndim; ++i) {
if (axes[i] < 0) {
axes[i] += ndim_;
if (axes.at(i) < 0) {
axes.at(i) += ndim_;
}
}
}
@ -321,20 +321,20 @@ int StridedSlice::HandleAxesInputExist(const std::vector<lite::Tensor *> &inputs
strides_.assign(ndim_, 0);
auto input_shape = input_tensor->shape();
for (int i = 0; i < ndim_; ++i) {
in_shape_[i] = input_shape.at(i);
in_shape_.at(i) = input_shape.at(i);
}
for (int i = 0; i < ndim_; ++i) {
auto axes_it = std::find(axes.begin(), axes.end(), i);
if (axes_it != axes.end()) {
auto axis = axes_it - axes.begin();
// begins or ends exceed limit will be set to limit
begins_[i] = std::max(std::min(begin_data[axis], input_shape[i] - 1), -input_shape[i]);
ends_[i] = std::max(std::min(end_data[axis], input_shape[i]), -input_shape[i] - 1);
strides_[i] = stride_data[axis];
begins_.at(i) = std::max(std::min(begin_data[axis], input_shape.at(i) - 1), -input_shape.at(i));
ends_.at(i) = std::max(std::min(end_data[axis], input_shape.at(i)), -input_shape.at(i) - 1);
strides_.at(i) = stride_data[axis];
} else {
begins_[i] = 0;
ends_[i] = input_shape[i];
strides_[i] = 1;
begins_.at(i) = 0;
ends_.at(i) = input_shape.at(i);
strides_.at(i) = 1;
}
}
return RET_OK;
@ -353,7 +353,7 @@ int StridedSlice::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
}
auto input = inputs.at(0);
outputs.front()->set_data_type(input->data_type());
outputs[0]->set_format(input->format());
outputs.at(0)->set_format(input->format());
MS_ASSERT(input != nullptr);
auto input_shape = input->shape();
auto inferflag = infer_flag();
@ -369,9 +369,9 @@ int StridedSlice::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
if (inferflag) {
in_shape_.emplace_back(input_shape.at(i));
}
begins_.emplace_back((GetBegin())[i]);
ends_.emplace_back((GetEnd())[i]);
strides_.emplace_back((GetStride())[i]);
begins_.emplace_back((GetBegin()).at(i));
ends_.emplace_back((GetEnd()).at(i));
strides_.emplace_back((GetStride()).at(i));
}
}
if (!CheckInputs(inputs)) {

56
mindspore/lite/src/ops/tensor_list.cc
View File

@ -31,10 +31,10 @@ int TensorListFromTensor::InferShape(std::vector<lite::Tensor *> inputs_, std::v
// outputs0: vector<tensor>.size() dtype
// outputs1: element_shape
// outputs2-n: vector<tensor>
auto input = inputs_[0];
auto input = inputs_.at(0);
MS_ASSERT(input != nullptr);
std::vector<int> in_shape = input->shape();
int dim0 = in_shape[0];
int dim0 = in_shape.at(0);
if (dim0 <= 0) {
MS_LOG(ERROR) << "inputs_[0] dim0:" << dim0 << " must greater than 0";
return RET_ERROR;
@ -46,29 +46,29 @@ int TensorListFromTensor::InferShape(std::vector<lite::Tensor *> inputs_, std::v
return RET_ERROR;
}
for (int i = 0; i < dim0; ++i) {
auto output = outputs_[i + 2];
auto output = outputs_.at(i + 2);
MS_ASSERT(output != nullptr);
output->set_data_type(input->data_type());
output->set_shape(out_shape);
}
auto output = outputs_[0]; // vector<tensor>.size(), tensorlist.dtype
auto output = outputs_.at(0); // vector<tensor>.size(), tensorlist.dtype
MS_ASSERT(output != nullptr);
output->set_data_type(kNumberTypeInt);
output->set_shape(std::vector<int>(1, 2)); // one element.value = 2
output = outputs_[1]; // element_shape tensor
output = outputs_.at(1); // element_shape tensor
MS_ASSERT(output != nullptr);
output->set_data_type(inputs_[1]->data_type());
output->set_format(inputs_[1]->format());
output->set_shape(inputs_[1]->shape());
output->set_data_type(inputs_.at(1)->data_type());
output->set_format(inputs_.at(1)->format());
output->set_shape(inputs_.at(1)->shape());
return RET_OK;
}
bool TensorListGetItem::IsFullyDefined(const std::vector<int> &shape) const {
for (size_t i = 0; i < shape.size(); ++i) {
if (shape[i] < 0) {
if (shape.at(i) < 0) {
return false;
}
}
@ -77,21 +77,21 @@ bool TensorListGetItem::IsFullyDefined(const std::vector<int> &shape) const {
int TensorListGetItem::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Tensor *> outputs_) {
int in_vec_size = inputs_.size();
auto input0 = inputs_[0];
auto input0 = inputs_.at(0);
MS_ASSERT(input0 != nullptr);
auto in0_ptr = reinterpret_cast<int *>(input0->data_c());
if (in_vec_size != in0_ptr[0] + 4) {
MS_LOG(ERROR) << "inputs_.size():" << in_vec_size << " must be equal to:" << in0_ptr[0] + 4;
return RET_ERROR;
}
auto get_index = inputs_[in0_ptr[0] + 2];
auto get_index = inputs_.at(in0_ptr[0] + 2);
MS_ASSERT(get_index != nullptr);
index_ = reinterpret_cast<int *>(get_index->data_c())[0];
if (index_ < 0 || index_ > in0_ptr[0]) {
MS_LOG(ERROR) << "index_:" << index_ << "must in [0, " << in0_ptr[0] << "]";
return RET_ERROR;
}
auto input_index = inputs_[index_ + 2];
auto input_index = inputs_.at(index_ + 2);
MS_ASSERT(input_index != nullptr);
auto output = outputs_.front();
MS_ASSERT(output != nullptr);
@ -100,7 +100,7 @@ int TensorListGetItem::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
output->set_data_type(input_index->data_type());
output->set_shape(input_index->shape());
} else {
auto ele_shape_tensor = inputs_[in0_ptr[0] + 3];
auto ele_shape_tensor = inputs_.at(in0_ptr[0] + 3);
MS_ASSERT(ele_shape_tensor != nullptr);
auto ele_shape_type = ele_shape_tensor->data_type();
if (ele_shape_type != kNumberTypeInt) {
@ -114,11 +114,11 @@ int TensorListGetItem::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
}
if (!IsFullyDefined(element_shape_)) {
for (int i = 0; i < in0_ptr[0]; ++i) {
auto input = inputs_[i + 2];
auto input = inputs_.at(i + 2);
if (input->data_type() != kTypeUnknown) {
std::vector<int> tmp = input->shape();
for (size_t j = 0; j < tmp.size(); ++j) {
element_shape_[j] = element_shape_[j] >= 0 ? element_shape_[j] : tmp[j];
element_shape_.at(j) = element_shape_.at(j) >= 0 ? element_shape_.at(j) : tmp.at(j);
}
}
}
@ -189,7 +189,7 @@ int TensorListReserve::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
<< " must be \"kNumberTypeInt\":" << kNumberTypeInt;
return RET_ERROR;
}
auto input1 = inputs_[1];
auto input1 = inputs_.at(1);
MS_ASSERT(input1 != nullptr);
auto num_ele_type = input1->data_type();
if (num_ele_type != kNumberTypeInt) {
@ -204,18 +204,18 @@ int TensorListReserve::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
}
for (int i = 0; i < num_elements; ++i) {
auto output = outputs_[i + 2];
auto output = outputs_.at(i + 2);
MS_ASSERT(output != nullptr);
output->set_data_type(kTypeUnknown);
output->set_shape(std::vector<int>(1, 0)); // shape = [0]
}
auto output = outputs_[0]; // vector<tensor>.size(), tensorlist.dtype
auto output = outputs_.at(0); // vector<tensor>.size(), tensorlist.dtype
MS_ASSERT(output != nullptr);
output->set_data_type(kNumberTypeInt);
output->set_shape(std::vector<int>(1, 2)); // one element.value = 2
output = outputs_[1]; // element_shape tensor
output = outputs_.at(1); // element_shape tensor
MS_ASSERT(output != nullptr);
output->set_data_type(input0->data_type());
output->set_format(input0->format());
@ -225,7 +225,7 @@ int TensorListReserve::InferShape(std::vector<lite::Tensor *> inputs_, std::vect
bool TensorListStack::IsFullyDefined(const std::vector<int> &shape) const {
for (size_t i = 0; i < shape.size(); ++i) {
if (shape[i] < 0) {
if (shape.at(i) < 0) {
return false;
}
}
@ -243,16 +243,16 @@ int TensorListStack::InferShape(std::vector<lite::Tensor *> inputs_, std::vector
MS_LOG(ERROR) << "inputs_.size():" << vec_in_size << " must be equal:" << input0_ptr[0] + 3;
return RET_ERROR;
}
auto ele_shape = inputs_[input0_ptr[0] + 2]; // element shape
auto ele_shape = inputs_.at(input0_ptr[0] + 2); // element shape
MS_ASSERT(ele_shape != nullptr);
auto ele_shape_ptr = reinterpret_cast<int *>(ele_shape->data_c());
for (int i = 0; ele_shape->ElementsNum(); ++i) {
output_shape_.push_back(ele_shape_ptr[i]);
}
std::vector<int> tensorlist_shape;
MS_ASSERT(inputs_[1] != nullptr);
auto input1_ptr = reinterpret_cast<int *>(inputs_[1]->data_c());
for (int i = 0; i < inputs_[1]->ElementsNum(); ++i) {
MS_ASSERT(inputs_.at(1) != nullptr);
auto input1_ptr = reinterpret_cast<int *>(inputs_.at(1)->data_c());
for (int i = 0; i < inputs_.at(1)->ElementsNum(); ++i) {
tensorlist_shape.push_back(input1_ptr[i]);
}
auto status = MergeShape(tensorlist_shape);
@ -266,7 +266,7 @@ int TensorListStack::InferShape(std::vector<lite::Tensor *> inputs_, std::vector
}
if (!IsFullyDefined(tensorlist_shape)) {
for (int i = 0; i < input0_ptr[0]; ++i) { // get tensorlist every tensor
auto tensor_tmp = inputs_[i + 2];
auto tensor_tmp = inputs_.at(i + 2);
MS_ASSERT(tensor_tmp != nullptr);
if (tensor_tmp->data_type() != kTypeUnknown) {
status = MergeShape(tensor_tmp->shape());
@ -298,15 +298,15 @@ int TensorListStack::MergeShape(const std::vector<int> &shape) {
return RET_ERROR;
}
for (size_t i = 0; i < dim0; ++i) {
int dim0_size = shape[i];
int dim1_size = output_shape_[i];
int dim0_size = shape.at(i);
int dim1_size = output_shape_.at(i);
if (dim0_size >= 0 && dim1_size >= 0 && dim0_size != dim1_size) {
MS_LOG(ERROR) << "shape[" << i << "]:" << dim0_size << " is incompatible with output_shape_[" << i
<< "]:" << dim1_size;
return RET_ERROR;
}
int tmp_size = dim1_size >= 0 ? dim1_size : dim0_size;
output_shape_[i] = tmp_size;
output_shape_.at(i) = tmp_size;
}
return RET_OK;
}

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

@ -160,10 +160,14 @@ int Tile::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
MS_ASSERT(multiples.size() == dims.size());
for (size_t i = 0; i < in_dims; ++i) {
out_shape.push_back(input->shape()[i]);
out_shape.push_back(input->shape().at(i));
}
for (size_t i = 0; i < dims.size(); ++i) {
out_shape[dims[i]] = input->shape()[dims[i]] * (multiples[i]);
if (multiples.at(i) > std::numeric_limits<int>::max() / input->shape().at(dims.at(i))) {
MS_LOG(ERROR) << "The value of multiples[" << i << "] is too big";
return RET_ERROR;
}
out_shape.at(dims.at(i)) = input->shape().at(dims.at(i)) * (multiples.at(i));
}
#endif
output->set_shape(out_shape);

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

@ -72,9 +72,9 @@ int TopK::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> output
return RET_OK;
}
auto out_shape = input->shape();
out_shape[out_shape.size() - 1] = GetK();
out_shape.at(out_shape.size() - 1) = GetK();
if (inputs_.size() == kDoubleNum && inputs_.at(1)->data_c() != nullptr) {
out_shape[out_shape.size() - 1] = reinterpret_cast<int *>(inputs_.at(1)->data_c())[0];
out_shape.at(out_shape.size() - 1) = reinterpret_cast<int *>(inputs_.at(1)->data_c())[0];
}
output0->set_shape(out_shape);
output1->set_shape(out_shape);

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

@ -62,7 +62,7 @@ int Transpose::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &
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);
attr->perm.emplace_back(CastToInt(elem).front());
}
@ -134,13 +134,13 @@ int Transpose::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> o
}
std::vector<int> perm;
for (size_t i = 0; i < GetPerm().size(); i++) {
perm.push_back(GetPerm()[i]);
perm.push_back(GetPerm().at(i));
}
std::vector<int> in_shape = input->shape();
std::vector<int> out_shape;
out_shape.resize(perm.size());
for (size_t i = 0; i < perm.size(); ++i) {
out_shape[i] = in_shape[perm[i]];
out_shape.at(i) = in_shape.at(perm.at(i));
}
output->set_shape(out_shape);
return RET_OK;

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

@ -46,8 +46,8 @@ int UnsortedSegmentSum::UnPackAttr(const Primitive &prim, const std::vector<AnfN
}
if (this->primitive_->value.value == nullptr) {
std::unique_ptr<schema::UnsortedSegmentSumT> attr = std::make_unique<schema::UnsortedSegmentSumT>();
if (inputs[2]->isa<ValueNode>()) {
ValuePtr value = inputs[2]->cast<ValueNodePtr>()->value();
if (inputs.at(2)->isa<ValueNode>()) {
ValuePtr value = inputs.at(2)->cast<ValueNodePtr>()->value();
attr->numSegments = CastToInt(value).front();
this->primitive_->value.value = attr.release();
}
@ -92,14 +92,14 @@ int UnsortedSegmentSum::InferShape(std::vector<Tensor *> inputs_, std::vector<Te
}
Tensor *out = outputs_.front();
Tensor *x = inputs_.front();
Tensor *segment_id = inputs_[1];
Tensor *segment_id = inputs_.at(1);
std::vector<int> x_shape = x->shape();
std::vector<int> segment_id_shape = segment_id->shape();
int num_segments = GetNumSegments();
std::vector<int> output_shape;
output_shape.push_back(num_segments);
for (int index = segment_id_shape.size(); index < static_cast<int>(x_shape.size()); index++) {
output_shape.push_back(x_shape[index]);
output_shape.push_back(x_shape.at(index));
}
out->set_shape(output_shape);
out->set_format(x->format());

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

@ -97,14 +97,14 @@ int Unsqueeze::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> o
size_t in_itr = 0;
size_t ax_itr = 0;
for (size_t i = 0; i < sz; i++) {
if (ax_itr < dim_rank && dims[ax_itr] == static_cast<int>(i)) {
if (ax_itr < dim_rank && dims.at(ax_itr) == static_cast<int>(i)) {
out_shape.emplace_back(1);
ax_itr++;
} else if (ax_itr < dim_rank && dims[ax_itr] + sz == i) {
} else if (ax_itr < dim_rank && dims.at(ax_itr) + sz == i) {
out_shape.emplace_back(1);
ax_itr++;
} else {
out_shape.emplace_back(in_shape[in_itr]);
out_shape.emplace_back(in_shape.at(in_itr));
in_itr++;
}
}

10
mindspore/lite/src/ops/upsample.cc
View File

@ -73,7 +73,7 @@ int Upsample::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::
auto scale_tensor = inputs_.at(1);
MS_ASSERT(scale_tensor);
auto scale_shape = scale_tensor->shape();
if (scale_shape.size() != 1 && scale_shape[0] != 4) {
if (scale_shape.size() != 1 && scale_shape.at(0) != 4) {
MS_LOG(ERROR) << "Upsample scale tensor shape should be 4";
return RET_INFER_ERR;
}
@ -84,12 +84,12 @@ int Upsample::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::
}
std::vector<int> out_shape = input_shape; // n, h, w, c; n, c not changed, h = floor(input_h * scale_h).
int new_height = static_cast<int>(floor(input_shape[1] * scale[1]));
int new_height = static_cast<int>(floor(input_shape.at(1) * scale[1]));
MS_ASSERT(new_height > 0);
int new_width = static_cast<int>(floor(input_shape[2] * scale[2]));
int new_width = static_cast<int>(floor(input_shape.at(2) * scale[2]));
MS_ASSERT(new_width > 0);
out_shape[1] = new_height;
out_shape[2] = new_width;
out_shape.at(1) = new_height;
out_shape.at(2) = new_width;
auto out_tensor = outputs_.at(0);
MS_ASSERT(out_tensor);

12
mindspore/lite/src/ops/where.cc
View File

@ -93,28 +93,28 @@ int Where::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outpu
int axisout = 0;
size_t temp = 0;
for (size_t j = 0; j < shape_tmp.size(); j++) {
if (shape_tmp[j] == shape_tmp1[j] && shape_tmp[j] != shape_tmp2[j]) {
if (shape_tmp.at(j) == shape_tmp1.at(j) && shape_tmp.at(j) != shape_tmp2.at(j)) {
axisout = j;
break;
}
if (shape_tmp[j] == shape_tmp2[j] && shape_tmp[j] != shape_tmp1[j]) {
if (shape_tmp.at(j) == shape_tmp2.at(j) && shape_tmp.at(j) != shape_tmp1.at(j)) {
axisout = j;
break;
}
if (shape_tmp1[j] == shape_tmp2[j] && shape_tmp[j] != shape_tmp1[j]) {
if (shape_tmp1.at(j) == shape_tmp2.at(j) && shape_tmp.at(j) != shape_tmp1.at(j)) {
axisout = j;
break;
}
temp += 1;
if (temp == shape_tmp.size()) {
outputs_[0]->set_shape(shape_tmp);
outputs_.at(0)->set_shape(shape_tmp);
output->set_data_type(input->data_type());
return RET_OK;
}
}
auto output_shape = shape_tmp;
output_shape[axisout] = nummax;
outputs_[0]->set_shape(output_shape);
output_shape.at(axisout) = nummax;
outputs_.at(0)->set_shape(output_shape);
return RET_OK;
}
} // namespace lite

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

@ -96,9 +96,9 @@ int While::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outpu
return RET_ERROR;
}
for (size_t i = 0; i < inputs_.size(); i++) {
outputs_[i]->set_data_type(inputs_[i]->data_type());
outputs_[i]->set_format(inputs_[i]->format());
outputs_[i]->set_shape(inputs_[i]->shape());
outputs_.at(i)->set_data_type(inputs_.at(i)->data_type());
outputs_.at(i)->set_format(inputs_.at(i)->format());
outputs_.at(i)->set_shape(inputs_.at(i)->shape());
}
return RET_OK;

12
mindspore/lite/src/runtime/kernel/arm/base/reduce_base.cc
View File

@ -131,16 +131,16 @@ void ReduceBaseCPUKernel::CalculateInnerOuterSize() {
int axis = axes_[i];
auto outer_size = 1;
for (int j = 0; j < axis; j++) {
outer_size *= tmp_shape[j];
outer_size *= tmp_shape.at(j);
}
outer_sizes_.emplace_back(outer_size);
auto inner_size = 1;
for (int k = axis + 1; k < static_cast<int>(tmp_shape.size()); k++) {
inner_size *= tmp_shape[k];
inner_size *= tmp_shape.at(k);
}
inner_sizes_.emplace_back(inner_size);
axis_sizes_.emplace_back(tmp_shape[axis]);
tmp_shape[axis] = 1;
axis_sizes_.emplace_back(tmp_shape.at(axis));
tmp_shape.at(axis) = 1;
}
}
@ -152,12 +152,12 @@ void ReduceBaseCPUKernel::CalculateTmpBufferSize() {
size_t size = 1;
for (size_t j = 0; j < input_shape.size(); j++) {
if (axis != static_cast<int>(j)) {
size *= input_shape[j];
size *= input_shape.at(j);
}
}
MS_ASSERT(context_->allocator != nullptr);
buffer_sizes_.emplace_back(size);
input_shape[axis] = 1;
input_shape.at(axis) = 1;
}
}

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

@ -57,7 +57,7 @@ int ResizeBaseCPUKernel::CheckParameters() {
return RET_INVALID_OP_ATTR;
}
} else if (this->in_tensors_.size() == lite::kDoubleNum) {
auto out_shape = this->in_tensors_[1]->data_c();
auto out_shape = this->in_tensors_.at(1)->data_c();
if (out_shape == nullptr) {
MS_LOG(INFO) << "Out shape is not assigned";
const_shape_ = false;

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

@ -48,8 +48,8 @@ int SoftmaxBaseCPUKernel::ReSize() {
softmax_param_->axis_ += in_dims;
}
for (size_t i = 0; i < in_dims; i++) {
softmax_param_->input_shape_[i] = in_shape[i];
ele_size *= in_shape[i];
softmax_param_->input_shape_[i] = in_shape.at(i);
ele_size *= in_shape.at(i);
}
softmax_param_->element_size_ = ele_size;
return RET_OK;

10
mindspore/lite/src/runtime/kernel/arm/base/split_base.cc
View File

@ -41,21 +41,21 @@ int SplitBaseCPUKernel::ReSize() {
MS_ASSERT(input_shape.size() >= 2 && input_shape.size() <= SPLIT_STRIDES_SIZE);
param->strides_[input_shape.size() - 1] = 1;
for (int i = input_shape.size() - 2; i >= 0; i--) {
param->strides_[i] = param->strides_[i + 1] * input_shape[i + 1];
param->strides_[i] = param->strides_[i + 1] * input_shape.at(i + 1);
}
MS_ASSERT(static_cast<size_t>(param->split_dim_) < input_shape.size());
param->split_count_ =
param->strides_[0] * input_shape[0] / (input_shape[param->split_dim_] * param->strides_[param->split_dim_]);
param->strides_[0] * input_shape.at(0) / (input_shape.at(param->split_dim_) * param->strides_[param->split_dim_]);
param->n_dims_ = input_shape.size();
if (param->split_sizes_[0] == 0) {
MS_ASSERT(param->num_split_ > 0 && static_cast<int>(param->num_split_) < input_shape.size());
if (input_shape[param->split_dim_] % param->num_split_ != 0) {
if (input_shape.at(param->split_dim_) % param->num_split_ != 0) {
MS_LOG(ERROR) << "Default split size is not usable.";
return RET_ERROR;
}
int split_size = input_shape[param->split_dim_] / param->num_split_;
int split_size = input_shape.at(param->split_dim_) / param->num_split_;
for (int i = 0; i < param->num_split_; i++) {
param->split_sizes_[i] = split_size;
}
@ -63,7 +63,7 @@ int SplitBaseCPUKernel::ReSize() {
MS_ASSERT(param->num_split_ >= 1 && param->num_split_ <= SPLIT_STRIDES_SIZE);
if (param->split_sizes_[param->num_split_ - 1] == -1) {
int split_shape_end = input_shape[param->split_dim_];
int split_shape_end = input_shape.at(param->split_dim_);
for (int i = 0; i < param->num_split_ - 1; i++) {
split_shape_end -= param->split_sizes_[i];
}

8
mindspore/lite/src/runtime/kernel/arm/fp16/reduce_fp16.cc
View File

@ -92,10 +92,10 @@ int ReduceFp16CPUKernel::Run() {
fp16_src_data_ = fp16_input_;
for (size_t i = 0; i < data_buffers_.size(); ++i) {
fp16_dst_data_ = data_buffers_[i];
outer_size_ = outer_sizes_[i];
inner_size_ = inner_sizes_[i];
axis_size_ = axis_sizes_[i];
fp16_dst_data_ = data_buffers_.at(i);
outer_size_ = outer_sizes_.at(i);
inner_size_ = inner_sizes_.at(i);
axis_size_ = axis_sizes_.at(i);
auto error_code = ParallelLaunch(this->context_->thread_pool_, ReduceFp16Impl, this, context_->thread_num_);
if (error_code != RET_OK) {
FreeTmpBuffer();

12
mindspore/lite/src/runtime/kernel/arm/fp16/split_fp16.cc
View File

@ -39,7 +39,7 @@ int SplitFp16CPUKernel::Init() {
}
output_ptr_.resize(param->num_split_);
for (size_t i = 0; i < output_ptr_.size(); i++) {
output_ptr_[i] = nullptr;
output_ptr_.at(i) = nullptr;
}
if (!InferShapeDone()) {
return RET_OK;
@ -82,8 +82,8 @@ int SplitFp16CPUKernel::Run() {
return RET_ERROR;
}
for (int i = 0; i < param->num_split_; i++) {
output_ptr_[i] = MallocOutputFp16(out_tensors_.at(i), context_);
if (output_ptr_[i] == nullptr) {
output_ptr_.at(i) = MallocOutputFp16(out_tensors_.at(i), context_);
if (output_ptr_.at(i) == nullptr) {
FreeInputAndOutput();
MS_LOG(ERROR) << "input or output is nullptr";
return RET_ERROR;
@ -92,7 +92,7 @@ int SplitFp16CPUKernel::Run() {
auto ret = ParallelLaunch(this->context_->thread_pool_, SplitFp16Run, this, thread_n_num_);
for (int i = 0; i < param->num_split_; i++) {
if (out_tensors_.at(i)->data_type() == kNumberTypeFloat32) {
Float16ToFloat32(output_ptr_[i], reinterpret_cast<float *>(out_tensors_.at(i)->MutableData()),
Float16ToFloat32(output_ptr_.at(i), reinterpret_cast<float *>(out_tensors_.at(i)->MutableData()),
out_tensors_.at(i)->ElementsNum());
}
}
@ -110,8 +110,8 @@ void SplitFp16CPUKernel::FreeInputAndOutput() {
}
for (int i = 0; i < param->num_split_; i++) {
if (out_tensors_.at(i)->data_type() == kNumberTypeFloat32) {
context_->allocator->Free(output_ptr_[i]);
output_ptr_[i] = nullptr;
context_->allocator->Free(output_ptr_.at(i));
output_ptr_.at(i) = nullptr;
}
}
}

20
mindspore/lite/src/runtime/kernel/arm/fp16/stack_fp16.cc
View File

@ -40,22 +40,22 @@ int StackFp16CPUKernel::Init() {
void StackFp16CPUKernel::InitMallocFlags() {
malloc_buffers_.resize(in_tensors_.size());
for (size_t i = 0; i < in_tensors_.size(); ++i) {
malloc_buffers_[i] = in_tensors_[i]->data_type() == kNumberTypeFloat32;
malloc_buffers_.at(i) = in_tensors_.at(i)->data_type() == kNumberTypeFloat32;
}
malloc_out = out_tensors_[0]->data_type() == kNumberTypeFloat32;
malloc_out = out_tensors_.at(0)->data_type() == kNumberTypeFloat32;
}
int StackFp16CPUKernel::MallocAssignBuffer() {
buffers_.resize(in_tensors_.size(), nullptr);
for (size_t i = 0; i < in_tensors_.size(); ++i) {
buffers_[i] = ConvertInputFp32toFp16(in_tensors_[i], context_);
if (buffers_[i] == nullptr) {
buffers_.at(i) = ConvertInputFp32toFp16(in_tensors_.at(i), context_);
if (buffers_.at(i) == nullptr) {
return RET_ERROR;
}
}
out_buffer_ = nullptr;
out_buffer_ = MallocOutputFp16(out_tensors_[0], context_);
out_buffer_ = MallocOutputFp16(out_tensors_.at(0), context_);
if (out_buffer_ == nullptr) {
return RET_ERROR;
}
@ -64,9 +64,9 @@ int StackFp16CPUKernel::MallocAssignBuffer() {
void StackFp16CPUKernel::FreeBuffer() {
for (size_t i = 0; i < buffers_.size(); ++i) {
if (malloc_buffers_[i] && buffers_[i] != nullptr) {
context_->allocator->Free(buffers_[i]);
buffers_[i] = nullptr;
if (malloc_buffers_.at(i) && buffers_.at(i) != nullptr) {
context_->allocator->Free(buffers_.at(i));
buffers_.at(i) = nullptr;
}
}
if (malloc_out && out_buffer_ != nullptr) {
@ -77,9 +77,9 @@ void StackFp16CPUKernel::FreeBuffer() {
int StackFp16CPUKernel::Run() {
size_t inputs_num = in_tensors_.size();
auto input0 = in_tensors_[0];
auto input0 = in_tensors_.at(0);
if (inputs_num == 1) {
memcpy(out_tensors_[0]->MutableData(), input0->MutableData(), input0->Size());
memcpy(out_tensors_.at(0)->MutableData(), input0->MutableData(), input0->Size());
return RET_OK;
}
InitMallocFlags();

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

@ -39,7 +39,7 @@ int TransposeFp16CPUKernel::Init() {
int TransposeFp16CPUKernel::ReSize() {
TransposeParameter *param = reinterpret_cast<TransposeParameter *>(this->op_parameter_);
num_unit_ = static_cast<int>(in_tensors_[kInputIndex]->shape().at(param->perm_[kNHWC_H]));
num_unit_ = static_cast<int>(in_tensors_.at(kInputIndex)->shape().at(param->perm_[kNHWC_H]));
thread_h_num_ = MSMIN(thread_num_, num_unit_);
thread_h_stride_ = UP_DIV(num_unit_, thread_h_num_);
auto &in_tensor = in_tensors_.front();
@ -50,8 +50,8 @@ int TransposeFp16CPUKernel::ReSize() {
param->out_strides_[param->num_axes_ - 1] = 1;
param->data_size_ = in_tensor->Size();
for (int i = param->num_axes_ - 2; i >= 0; i--) {
param->strides_[i] = in_shape[i + 1] * param->strides_[i + 1];
param->out_strides_[i] = out_shape[i + 1] * param->out_strides_[i + 1];
param->strides_[i] = in_shape.at(i + 1) * param->strides_[i + 1];
param->out_strides_[i] = out_shape.at(i + 1) * param->out_strides_[i + 1];
}
return RET_OK;

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

@ -41,7 +41,7 @@ bool TensorListFromTensorCPUKernel::IsCompatibleShape() {
}
int *elements_shape = reinterpret_cast<int *>(input1_->data_c()); // element shape in tensor data
for (int i = 0; i < in1_ele_num; ++i) {
const int dim0 = tensor_shape[i + 1];
const int dim0 = tensor_shape.at(i + 1);
const int dim1 = *(elements_shape + i);
if (dim0 >= 0 && dim1 >= 0 && dim0 != dim1) {
MS_LOG(ERROR) << "input0_->shape()[" << i + 1 << "]:" << dim0 << " is not equal input1_->data_c()[" << i
@ -53,17 +53,17 @@ bool TensorListFromTensorCPUKernel::IsCompatibleShape() {
}
int TensorListFromTensorCPUKernel::Init() {
input0_ = in_tensors_[0]; // row tensor
input1_ = in_tensors_[1]; // element_shape tensor
output0_ = out_tensors_[0];
output1_ = out_tensors_[1];
input0_ = in_tensors_.at(0); // row tensor
input1_ = in_tensors_.at(1); // element_shape tensor
output0_ = out_tensors_.at(0);
output1_ = out_tensors_.at(1);
return IsCompatibleShape();
}
int TensorListFromTensorCPUKernel::ReSize() { return RET_OK; }
int TensorListFromTensorCPUKernel::Run() {
int dim0 = input0_->shape()[0];
int dim0 = input0_->shape().at(0);
size_t devision_dim0 = input0_->ElementsNum() / dim0;
auto out0_ptr = reinterpret_cast<int *>(output0_->MutableData());
*out0_ptr = dim0;
@ -81,7 +81,7 @@ int TensorListFromTensorCPUKernel::Run() {
auto in_ptr = reinterpret_cast<float *>(input0_);
size_t index = 0;
for (int i = 0; i < dim0; ++i) {
auto out_ptr = reinterpret_cast<float *>(out_tensors_[i + 2]->MutableData());
auto out_ptr = reinterpret_cast<float *>(out_tensors_.at(i + 2)->MutableData());
memcpy(out_ptr, in_ptr + index, devision_dim0 * sizeof(float));
index += devision_dim0;
}

12
mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.cc
View File

@ -29,14 +29,14 @@ using mindspore::schema::PrimitiveType_TensorListGetItem;
namespace mindspore::kernel {
int TensorListGetItemCPUKernel::Init() {
auto input0 = reinterpret_cast<int *>(in_tensors_[0]->data_c());
auto input0 = reinterpret_cast<int *>(in_tensors_.at(0)->data_c());
size_t dim0 = *input0;
int in_dtype = *(input0 + 1);
if (dtype_ != in_dtype) {
MS_LOG(ERROR) << "op dtype:" << dtype_ << " is not equal in_tensors dtype:" << in_dtype;
return RET_ERROR;
}
index_ = *(reinterpret_cast<int *>(in_tensors_[dim0 + 2]->data_c()));
index_ = *(reinterpret_cast<int *>(in_tensors_.at(dim0 + 2)->data_c()));
if (index_ < 0) {
MS_LOG(ERROR) << "index tensor:[" << index_ << "] must be greater than or equal to 0";
return RET_ERROR;
@ -50,16 +50,16 @@ int TensorListGetItemCPUKernel::Init() {
}
int TensorListGetItemCPUKernel::Run() {
if (in_tensors_[index_]->data_type() != kTypeUnknown) {
auto status = out_tensors_[0]->CopyTensorData(*in_tensors_[index_]); // tensorlist shape
if (in_tensors_.at(index_)->data_type() != kTypeUnknown) {
auto status = out_tensors_.at(0)->CopyTensorData(*in_tensors_.at(index_)); // tensorlist shape
if (status == RET_ERROR) {
MS_LOG(ERROR) << "copy tensor data failed!";
return RET_ERROR;
}
} else {
// reset 0 and dtype = dtype_
auto out_ptr = reinterpret_cast<char *>(out_tensors_[0]->MutableData());
memset(out_ptr, 0, lite::DataTypeSize(dtype_) * out_tensors_[0]->ElementsNum());
auto out_ptr = reinterpret_cast<char *>(out_tensors_.at(0)->MutableData());
memset(out_ptr, 0, lite::DataTypeSize(dtype_) * out_tensors_.at(0)->ElementsNum());
}
return RET_OK;
}

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

@ -30,10 +30,10 @@ namespace mindspore::kernel {
int TensorListReserveCPUKernel::Init() { return RET_OK; }
int TensorListReserveCPUKernel::Run() {
auto out0_ptr = reinterpret_cast<int *>(out_tensors_[0]->MutableData()); // tensorlist size() and dtype
out0_ptr[0] = reinterpret_cast<int *>(in_tensors_[0]->data_c())[0]; // num_elements
auto out0_ptr = reinterpret_cast<int *>(out_tensors_.at(0)->MutableData()); // tensorlist size() and dtype
out0_ptr[0] = reinterpret_cast<int *>(in_tensors_.at(0)->data_c())[0]; // num_elements
out0_ptr[1] = element_dtype_;
auto status = out_tensors_[1]->CopyTensorData(*in_tensors_[1]); // elements_shape
auto status = out_tensors_.at(1)->CopyTensorData(*in_tensors_.at(1)); // elements_shape
if (status == RET_ERROR) {
MS_LOG(ERROR) << "copy tensor data failed!";
return RET_ERROR;

18
mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.cc
View File

@ -29,12 +29,12 @@ using mindspore::schema::PrimitiveType_TensorListStack;
namespace mindspore::kernel {
int TensorListStackCPUKernel::CheckParam() {
auto in0_dtype = in_tensors_[0]->data_type();
auto in0_dtype = in_tensors_.at(0)->data_type();
if (in0_dtype != kNumberTypeInt) {
MS_LOG(ERROR) << "in_tensors_[0]->data_type():" << in0_dtype
<< " must be equal \"kNumberTypeInt\":" << kNumberTypeInt;
}
auto in0_ptr = reinterpret_cast<int *>(in_tensors_[0]->data_c());
auto in0_ptr = reinterpret_cast<int *>(in_tensors_.at(0)->data_c());
if (in0_ptr[1] != dtype_) {
MS_LOG(ERROR) << "in_tensors_[0].data_type:[" << in0_ptr[1] << "] must be equal "
<< "param.data_type:[" << dtype_ << "]";
@ -50,12 +50,12 @@ int TensorListStackCPUKernel::CheckParam() {
}
int TensorListStackCPUKernel::Init() {
output0_ = out_tensors_[0];
output0_ = out_tensors_.at(0);
if (output0_->format() != schema::Format_NC) { // shape().size() = 2
MS_LOG(ERROR) << "out_tensor_[0] format must be \"Format:NC\", but now is:" << output0_->format();
return RET_ERROR;
}
int dim0 = output0_->shape()[0];
int dim0 = output0_->shape().at(0);
if (dim0 != 1) { // dim0 must be 1
MS_LOG(ERROR) << "out_tensor_[0] dim0 must be 1, but now is:" << dim0;
return RET_ERROR;
@ -66,19 +66,19 @@ int TensorListStackCPUKernel::Init() {
int TensorListStackCPUKernel::Run() {
size_t in_ele_num = 0;
for (int i = 0; i < num_element_; ++i) {
in_ele_num += in_tensors_[i + 2]->ElementsNum();
in_ele_num += in_tensors_.at(i + 2)->ElementsNum();
}
size_t out_ele_num = out_tensors_[0]->ElementsNum();
size_t out_ele_num = out_tensors_.at(0)->ElementsNum();
if (in_ele_num > out_ele_num) {
MS_LOG(ERROR) << "out_tensors_[0]->ElementsNum():" << out_ele_num << "must greater than or equal to in_ele_num"
<< in_ele_num;
return RET_ERROR;
}
size_t index = 0;
auto out_ptr = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
auto out_ptr = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
for (int i = 0; i < num_element_; ++i) {
auto in_ptr = reinterpret_cast<float *>(in_tensors_[i + 2]->data_c());
size_t in_size = in_tensors_[i + 2]->ElementsNum();
auto in_ptr = reinterpret_cast<float *>(in_tensors_.at(i + 2)->data_c());
size_t in_size = in_tensors_.at(i + 2)->ElementsNum();
memcpy(out_ptr + index, in_ptr, in_size * sizeof(float));
index += in_size;
}

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

@ -140,13 +140,13 @@ int ReduceCPUKernel::Run() {
HandleASumAndSumSquare();
for (size_t i = 0; i < static_cast<size_t>(num_axes_); ++i) {
if (i != static_cast<size_t>(num_axes_ - 1)) {
dst_data_ = data_buffers_[i];
dst_data_ = data_buffers_.at(i);
} else {
dst_data_ = out_tensors_.at(0)->MutableData();
}
outer_size_ = outer_sizes_[i];
inner_size_ = inner_sizes_[i];
axis_size_ = axis_sizes_[i];
outer_size_ = outer_sizes_.at(i);
inner_size_ = inner_sizes_.at(i);
axis_size_ = axis_sizes_.at(i);
auto error_code = ParallelLaunch(this->context_->thread_pool_, ReduceImpl, this, context_->thread_num_);
if (error_code != RET_OK) {
MS_LOG(ERROR) << "Reduce run error, error_code[" << error_code << "]";

12
mindspore/lite/src/runtime/kernel/arm/fp32/resize_fp32.cc
View File

@ -51,7 +51,7 @@ int ResizeCPUKernel::ReSize() {
auto input = in_tensors_.at(0);
auto input_shape = input->shape();
ret = PrepareResizeBilinear(input_shape.data(), out_tensors_[0]->shape().data(), align_corners_, y_bottoms_,
ret = PrepareResizeBilinear(input_shape.data(), out_tensors_.at(0)->shape().data(), align_corners_, y_bottoms_,
y_tops_, x_lefts_, x_rights_, y_bottom_weights_, x_left_weights_);
if (ret != RET_OK) {
FreeTmpBuffer();
@ -164,15 +164,15 @@ int ResizeCPUKernel::RunImpl(int task_id) {
switch (method_) {
case static_cast<int>(schema::ResizeMethod_LINEAR): {
int n_h_begin, n_h_end;
int n = out_tensors_.at(0)->shape()[0];
int n = out_tensors_.at(0)->shape().at(0);
int h = new_height_;
int unit = UP_DIV(n * h, context_->thread_num_);
n_h_begin = unit * task_id;
n_h_end = std::min(n_h_begin + unit, n * h);
int c = in_tensors_.at(0)->shape()[3];
int c = in_tensors_.at(0)->shape().at(3);
float *line0 = line_buffer_ + new_width_ * c * 2 * task_id;
float *line1 = line0 + new_width_ * c;
ret = ResizeBilinear2(input_data, output_data, input_shape.data(), out_tensors_[0]->shape().data(), y_bottoms_,
ret = ResizeBilinear2(input_data, output_data, input_shape.data(), out_tensors_.at(0)->shape().data(), y_bottoms_,
y_tops_, x_lefts_, x_rights_, y_bottom_weights_, x_left_weights_, line0, line1, n_h_begin,
n_h_end);
@ -186,8 +186,8 @@ int ResizeCPUKernel::RunImpl(int task_id) {
MS_LOG(ERROR) << "The out shape data is nullptr.";
return RET_NULL_PTR;
} else {
out_tensors_[0]->shape()[1] = static_cast<int64_t>(data[0]);
out_tensors_[0]->shape()[2] = static_cast<int64_t>(data[1]);
out_tensors_.at(0)->shape().at(1) = static_cast<int64_t>(data[0]);
out_tensors_.at(0)->shape().at(2) = static_cast<int64_t>(data[1]);
}
}
ret = ResizeNearestNeighbor(input_data, output_data, input_shape.data(), out_tensors_[0]->shape().data(),

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

@ -31,8 +31,8 @@ namespace mindspore::kernel {
int ReverseCPUKernel::Stride(int index) {
int stride = 1;
for (size_t i = index + 1; i < in_tensors_[0]->shape().size(); ++i) {
stride *= in_tensors_[0]->shape()[i];
for (size_t i = index + 1; i < in_tensors_.at(0)->shape().size(); ++i) {
stride *= in_tensors_.at(0)->shape().at(i);
}
return stride;
}
@ -43,7 +43,7 @@ int ReverseCPUKernel::ReSize() {
thread_sz_stride_ = UP_DIV(data_size_, thread_sz_count_);
auto *param = reinterpret_cast<ReverseParameter *>(op_parameter_);
auto input_shape = in_tensors_[0]->shape();
auto input_shape = in_tensors_.at(0)->shape();
if (param->num_axis_ > static_cast<int>(input_shape.size())) {
MS_LOG(ERROR) << "Reverse dims : " << param->num_axis_
<< "is greater than input shape size :" << input_shape.size();
@ -72,7 +72,7 @@ int ReverseCPUKernel::ReSize() {
inCount_[i] = input_shape[axis];
outCount_[i] = 1;
for (int j = 0; j < axis; j++) {
outCount_[i] *= input_shape[j];
outCount_[i] *= input_shape.at(j);
}
}

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

@ -39,14 +39,14 @@ void ReverseSequenceCPUKernel::ConvertAxisToPositive(const std::vector<int> shap
int ReverseSequenceCPUKernel::CalcCountPreAxis(const std::vector<int> shape, int axis) {
int count = 1;
for (int i = 0; i < axis; ++i) {
count *= shape[i];
count *= shape.at(i);
}
return count;
}
int ReverseSequenceCPUKernel::CalcCountAfterAxis(const std::vector<int> shape, int axis) {
int count = 1;
for (size_t i = axis + 1; i < shape.size(); ++i) {
count *= shape[i];
count *= shape.at(i);
}
return count;
}

22
mindspore/lite/src/runtime/kernel/arm/fp32/roi_pooling_fp32.cc
View File

@ -50,21 +50,21 @@ int ROIPoolingCPUKernel::ReSize() {
return RET_ERROR;
}
param_->ndim_ = ndims;
param_->input_n_ = in_shape[0];
param_->input_h_ = in_shape[1];
param_->input_w_ = in_shape[2];
param_->input_c_ = in_shape[3];
param_->output_n_ = out_shape[0];
param_->output_h_ = out_shape[1];
param_->output_w_ = out_shape[2];
param_->output_c_ = out_shape[3];
param_->input_n_ = in_shape.at(0);
param_->input_h_ = in_shape.at(1);
param_->input_w_ = in_shape.at(2);
param_->input_c_ = in_shape.at(3);
param_->output_n_ = out_shape.at(0);
param_->output_h_ = out_shape.at(1);
param_->output_w_ = out_shape.at(2);
param_->output_c_ = out_shape.at(3);
param_->in_strides_[ndims - 1] = 1;
param_->out_strides_[ndims - 1] = 1;
for (int i = ndims - 2; i >= 0; --i) {
param_->in_strides_[i] = in_shape[i + 1] * param_->in_strides_[i + 1];
param_->out_strides_[i] = out_shape[i + 1] * param_->out_strides_[i + 1];
param_->in_strides_[i] = in_shape.at(i + 1) * param_->in_strides_[i + 1];
param_->out_strides_[i] = out_shape.at(i + 1) * param_->out_strides_[i + 1];
}
param_->thread_num_ = MSMIN(param_->op_parameter_.thread_num_, out_shape[0]);
param_->thread_num_ = MSMIN(param_->op_parameter_.thread_num_, out_shape.at(0));
max_c_ = reinterpret_cast<float *>(malloc(param_->input_c_ * sizeof(float)));
if (max_c_ == nullptr) {
MS_LOG(ERROR) << "malloc max_c failed.";

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

@ -101,17 +101,17 @@ int ScaleCPUKernel::CalculateParameter() {
scale_param_->axis_size_ = 1;
scale_param_->inner_size_ = 1;
for (int i = 0; i < scale_param_->axis_; i++) {
scale_param_->outer_size_ *= in_shape[i];
scale_param_->outer_size_ *= in_shape.at(i);
}
for (size_t i = 0; i < scale_shape.size(); i++) {
if (in_shape[i + scale_param_->axis_] != scale_shape[i]) {
if (in_shape.at(i + scale_param_->axis_) != scale_shape.at(i)) {
MS_LOG(ERROR) << "Scale tensor shape is incorrect.";
return RET_ERROR;
}
scale_param_->axis_size_ *= in_shape[i + scale_param_->axis_];
scale_param_->axis_size_ *= in_shape.at(i + scale_param_->axis_);
}
for (size_t i = scale_param_->axis_ + scale_shape.size(); i < in_shape.size(); i++) {
scale_param_->inner_size_ *= in_shape[i];
scale_param_->inner_size_ *= in_shape.at(i);
}
scale_param_->op_parameter_.thread_num_ = MSMIN(scale_param_->op_parameter_.thread_num_, scale_param_->outer_size_);
return RET_OK;
@ -177,7 +177,7 @@ int ScaleCPUKernel::Run() {
auto in_tensor = in_tensors_.front();
input_ptr_ = reinterpret_cast<float *>(in_tensor->data_c());
if (!scale_param_->const_scale_) {
auto scale_tensor = in_tensors_[1];
auto scale_tensor = in_tensors_.at(1);
scale_ = reinterpret_cast<float *>(scale_tensor->data_c());
}
if (!scale_param_->const_offset_) {

12
mindspore/lite/src/runtime/kernel/arm/fp32/scatter_nd_fp32.cc
View File

@ -73,13 +73,13 @@ int ScatterNDCPUKernel::ReSize() {
// check update shape
auto update_shape = update->shape();
for (size_t i = 0; i < indices_shape.size() - 1; i++) {
if (update_shape[i] != indices_shape[i]) {
if (update_shape.at(i) != indices_shape.at(i)) {
MS_LOG(ERROR) << "Value of " << i << " th dimension of indices is not equal to that of update.";
return RET_ERROR;
}
}
for (size_t i = 0; i < shape->ElementsNum() - (indices_shape.size() - 1); i++) {
if (update_shape[i + indices_shape.size() - 1] != shape_data[i + indices_shape.size() - 1]) {
if (update_shape.at(i + indices_shape.size() - 1) != shape_data[i + indices_shape.size() - 1]) {
MS_LOG(ERROR) << "Value of " << i + indices_shape.size() - 1
<< " th dimension of indices is not equal to the corresbonding dimension of shape.";
return RET_ERROR;
@ -90,7 +90,7 @@ int ScatterNDCPUKernel::ReSize() {
// calculate unit_size_
unit_size_ = 1;
for (int i = indices_shape.size() - 1; i < update_rank; i++) {
unit_size_ *= update_shape[i];
unit_size_ *= update_shape.at(i);
}
// calculate offsets
@ -102,9 +102,9 @@ int ScatterNDCPUKernel::ReSize() {
}
num_unit_ = 1;
num_unit_ *= update_shape[indices_shape.size() - 2];
num_unit_ *= update_shape.at(indices_shape.size() - 2);
for (int i = indices_shape.size() - 3; i >= 0; i--) {
num_unit_ *= update_shape[i];
num_unit_ *= update_shape.at(i);
}
int *indices_ptr = reinterpret_cast<int *>(indices->MutableData());
@ -112,7 +112,7 @@ int ScatterNDCPUKernel::ReSize() {
for (int i = 0; i < num_unit_; i++) {
int tmp_stride = 0;
for (int j = 0; j < indice_unit_rank; j++) {
tmp_stride += indices_ptr[i * indice_unit_rank + j] * out_strides_[j] * unit_size_;
tmp_stride += indices_ptr[i * indice_unit_rank + j] * out_strides_.at(j) * unit_size_;
}
output_unit_offsets_.push_back(tmp_stride);
}

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

@ -43,7 +43,7 @@ int ShapeCPUKernel::Run() {
}
for (size_t i = 0; i < in_tensor->shape().size(); i++) {
reinterpret_cast<int *>(out_tensor->MutableData())[i] = in_tensor->shape()[i];
reinterpret_cast<int *>(out_tensor->MutableData())[i] = in_tensor->shape().at(i);
}
return RET_OK;

18
mindspore/lite/src/runtime/kernel/arm/fp32/skip_gram_fp32.cc
View File

@ -68,7 +68,7 @@ int SkipGramCPUKernel::Run() {
return RET_ERROR;
}
StringPack sentence = mindspore::lite::ParseTensorBuffer(in_tensors_[0]).at(0);
StringPack sentence = mindspore::lite::ParseTensorBuffer(in_tensors_.at(0)).at(0);
std::vector<StringPack> words;
ParseSentenceToWords(sentence, &words);
@ -78,12 +78,12 @@ int SkipGramCPUKernel::Run() {
int index = 1;
int size = words.size();
while (index >= 0) {
if (index < skip_gram_parameter_->ngram_size && stack[index] + 1 < size &&
(index == 0 || stack[index] - stack[index - 1] <= skip_gram_parameter_->max_skip_size)) {
stack[index]++;
if (index < skip_gram_parameter_->ngram_size && stack.at(index) + 1 < size &&
(index == 0 || stack.at(index) - stack.at(index - 1) <= skip_gram_parameter_->max_skip_size)) {
stack.at(index)++;
index++;
if (index < skip_gram_parameter_->ngram_size) {
stack[index] = stack[index - 1];
stack.at(index) = stack.at(index - 1);
}
} else {
if (index > 0 && ((skip_gram_parameter_->include_all_ngrams && index <= skip_gram_parameter_->ngram_size) ||
@ -92,16 +92,16 @@ int SkipGramCPUKernel::Run() {
char blank[1] = {' '};
StringPack blank_str = {1, blank};
for (int i = 0; i < 2 * index - 2; i += 2) {
gram[i] = words[stack[i / 2]];
gram[i + 1] = blank_str;
gram.at(i) = words.at(stack.at(i / 2));
gram.at(i + 1) = blank_str;
}
gram[2 * index - 2] = words[stack[index - 1]];
gram.at(2 * index - 2) = words.at(stack.at(index - 1));
result.push_back(gram);
}
index--;
}
}
auto ret = mindspore::lite::WriteSeperatedStringsToTensor(out_tensors_[0], result);
auto ret = mindspore::lite::WriteSeperatedStringsToTensor(out_tensors_.at(0), result);
return ret;
}

12
mindspore/lite/src/runtime/kernel/arm/fp32/slice_fp32.cc
View File

@ -45,8 +45,8 @@ int SliceCPUKernel::ReSize() {
}
for (int i = 0; i < param_->param_length_; ++i) {
param_->shape_[i] = in_tensors_.at(0)->DimensionSize(i);
param_->begin_[i] = begin[i];
param_->size_[i] = size[i] < 0 ? param_->shape_[i] - param_->begin_[i] : size[i];
param_->begin_[i] = begin.at(i);
param_->size_[i] = size.at(i) < 0 ? param_->shape_[i] - param_->begin_[i] : size.at(i);
param_->end_[i] = param_->begin_[i] + param_->size_[i];
}
if (param_->param_length_ < DIMENSION_4D) {
@ -63,8 +63,8 @@ int SliceCPUKernel::Init() {
}
int SliceCPUKernel::SliceParallelRun(int thread_id) {
const float *input_data = reinterpret_cast<const float *>(in_tensors_[0]->MutableData());
float *output_data = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
const float *input_data = reinterpret_cast<const float *>(in_tensors_.at(0)->MutableData());
float *output_data = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(input_data);
MS_ASSERT(output_data);
DoSlice(input_data, output_data, param_, thread_id);
@ -77,8 +77,8 @@ int SliceCPUKernel::Run() {
MS_LOG(ERROR) << "PreProcess fail!ret: " << ret;
return ret;
}
const float *input_data = reinterpret_cast<const float *>(in_tensors_[0]->MutableData());
float *output_data = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
const float *input_data = reinterpret_cast<const float *>(in_tensors_.at(0)->MutableData());
float *output_data = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
if (param_->size_[1] < op_parameter_->thread_num_) {
DoSliceNoParallel(input_data, output_data, param_);
return RET_OK;

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

@ -51,11 +51,11 @@ int SoftmaxCPUKernel::ReSize() {
auto in_shape = in_tensors_.front()->shape();
int out_plane_size = 1;
for (int i = 0; i < axis; ++i) {
out_plane_size *= in_shape[i];
out_plane_size *= in_shape.at(i);
}
int in_plane_size = 1;
for (int i = axis + 1; i < n_dim; i++) {
in_plane_size *= in_shape[i];
in_plane_size *= in_shape.at(i);
}
in_plane_size_ = in_plane_size;
out_plane_size_ = out_plane_size;

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

@ -45,12 +45,12 @@ int SpaceToDepthCPUKernel::Init() {
}
int SpaceToDepthCPUKernel::ReSize() {
if (in_tensors_[0]->format() != schema::Format::Format_NHWC) {
if (in_tensors_.at(0)->format() != schema::Format::Format_NHWC) {
MS_LOG(ERROR) << "space_to_depth only support NHWC now!";
return RET_FORMAT_ERR;
}
num_unit_ = static_cast<int>(out_tensors_[0]->shape().at(kNHWC_H));
num_unit_ = static_cast<int>(out_tensors_.at(0)->shape().at(kNHWC_H));
thread_h_num_ = MSMIN(op_parameter_->thread_num_, num_unit_);
thread_h_stride_ = UP_DIV(num_unit_, thread_h_num_);
return RET_OK;
@ -62,8 +62,8 @@ int SpaceToDepthCPUKernel::SpaceToDepth(int task_id) {
return RET_OK;
}
int thread_offset = task_id * thread_h_stride_;
auto in_shape = in_tensors_[0]->shape();
auto out_shape = out_tensors_[0]->shape();
auto in_shape = in_tensors_.at(0)->shape();
auto out_shape = out_tensors_.at(0)->shape();
SpaceToDepthParameter *param = reinterpret_cast<SpaceToDepthParameter *>(op_parameter_);
MS_ASSERT(param);
MS_ASSERT(input_ptr_);
@ -88,9 +88,9 @@ int SpaceToDepthRun(void *cdata, int task_id) {
}
int SpaceToDepthCPUKernel::Run() {
input_ptr_ = reinterpret_cast<float *>(in_tensors_[0]->MutableData());
output_ptr_ = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
if (in_tensors_[0]->format() == schema::Format::Format_NHWC) {
input_ptr_ = reinterpret_cast<float *>(in_tensors_.at(0)->MutableData());
output_ptr_ = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
if (in_tensors_.at(0)->format() == schema::Format::Format_NHWC) {
auto ret = ParallelLaunch(this->context_->thread_pool_, SpaceToDepthRun, this, thread_h_num_);
if (ret != RET_OK) {
MS_LOG(ERROR) << "SpaceToDepth error error_code[" << ret << "]";

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

@ -91,7 +91,7 @@ int SparseToDenseRun(void *cdata, int task_id) {
int SparseToDenseCPUKernel::GenerateIndices() {
auto input0 = in_tensors_.at(0);
index_num = input0->shape()[0];
index_num = input0->shape().at(0);
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;
@ -120,7 +120,7 @@ int SparseToDenseCPUKernel::GenerateIndices() {
break;
}
case 2: {
int true_dims = input0->shape()[1];
int true_dims = input0->shape().at(1);
MS_ASSERT(true_dims <= DIMENSION_4D);
for (int i = 0; i < index_num; i++) {
sparse_indices_vect[i] = new int[DIMENSION_4D];

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

@ -77,7 +77,7 @@ int SplitCPUKernel::Run() {
auto in_tensor = in_tensors_.front();
input_ptr_ = reinterpret_cast<float *>(in_tensor->MutableData());
for (int i = 0; i < param->num_split_; i++) {
output_ptr_[i] = reinterpret_cast<float *>(out_tensors_.at(i)->MutableData());
output_ptr_.at(i) = reinterpret_cast<float *>(out_tensors_.at(i)->MutableData());
}
auto ret = ParallelLaunch(this->context_->thread_pool_, SplitRun, this, thread_n_num_);
if (ret != RET_OK) {

18
mindspore/lite/src/runtime/kernel/arm/fp32/stack_fp32.cc
View File

@ -29,7 +29,7 @@ using mindspore::schema::PrimitiveType_Stack;
namespace mindspore::kernel {
int StackCPUKernel::ReSize() {
StackParameter *param = reinterpret_cast<StackParameter *>(op_parameter_);
auto input0_shape = in_tensors_[0]->shape();
auto input0_shape = in_tensors_.at(0)->shape();
axis_ = param->axis_ < 0 ? param->axis_ + input0_shape.size() + 1 : param->axis_;
return RET_OK;
}
@ -44,31 +44,31 @@ int StackCPUKernel::Init() {
int StackCPUKernel::Run() {
size_t inputs_num = in_tensors_.size();
auto input0 = in_tensors_[0];
auto input0 = in_tensors_.at(0);
if (inputs_num == 1) {
auto *output_data = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
auto *output_data = reinterpret_cast<int8_t *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_data);
auto *input_data = reinterpret_cast<const int8_t *>(input0->MutableData());
MS_ASSERT(input_data);
DoStackOneInput(input_data, output_data, input0->Size());
return RET_OK;
}
auto input0_shape = in_tensors_[0]->shape();
if (in_tensors_[0]->data_type() == kNumberTypeFloat32 || in_tensors_[0]->data_type() == kNumberTypeFloat) {
auto *output_data = reinterpret_cast<float *>(out_tensors_[0]->MutableData());
auto input0_shape = in_tensors_.at(0)->shape();
if (in_tensors_.at(0)->data_type() == kNumberTypeFloat32 || in_tensors_.at(0)->data_type() == kNumberTypeFloat) {
auto *output_data = reinterpret_cast<float *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_data);
float *inputs[inputs_num];
for (size_t i = 0; i < inputs_num; ++i) {
inputs[i] = reinterpret_cast<float *>(in_tensors_[i]->MutableData());
inputs[i] = reinterpret_cast<float *>(in_tensors_.at(i)->MutableData());
MS_ASSERT(inputs[i]);
}
DoStack(inputs, inputs_num, input0_shape.data(), input0_shape.size(), axis_, output_data);
} else {
auto *output_data = reinterpret_cast<int32_t *>(out_tensors_[0]->MutableData());
auto *output_data = reinterpret_cast<int32_t *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_data);
int32_t *inputs[inputs_num];
for (size_t i = 0; i < inputs_num; ++i) {
inputs[i] = reinterpret_cast<int32_t *>(in_tensors_[i]->MutableData());
inputs[i] = reinterpret_cast<int32_t *>(in_tensors_.at(i)->MutableData());
MS_ASSERT(inputs[i]);
}
DoStackInt32(inputs, inputs_num, input0_shape.data(), input0_shape.size(), axis_, output_data);

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

@ -42,10 +42,10 @@ void TileCPUKernel::ComputeStrides(const int *shape, int *strides, int ndim) {
int TileCPUKernel::ReSize() {
auto tile_parameter_ = reinterpret_cast<TileParameter *>(op_parameter_);
MS_ASSERT(tile_parameter_);
tile_parameter_->in_dim_ = in_tensors_[0]->shape().size();
tile_parameter_->in_dim_ = in_tensors_.at(0)->shape().size();
for (int i = 0; i < tile_parameter_->in_dim_; ++i) {
tile_parameter_->in_shape_[i] = in_tensors_[0]->shape()[i];
tile_parameter_->out_shape_[i] = out_tensors_[0]->shape()[i];
tile_parameter_->in_shape_[i] = in_tensors_.at(0)->shape().at(i);
tile_parameter_->out_shape_[i] = out_tensors_.at(0)->shape().at(i);
}
ComputeStrides(tile_parameter_->in_shape_, tile_parameter_->in_strides_, tile_parameter_->in_dim_);
ComputeStrides(tile_parameter_->out_shape_, tile_parameter_->out_strides_, tile_parameter_->in_dim_);

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

@ -37,10 +37,10 @@ int TopKCPUKernel::Init() {
int TopKCPUKernel::ReSize() {
lite::Tensor *input = in_tensors_.at(0);
TopkParameter *parameter = reinterpret_cast<TopkParameter *>(op_parameter_);
parameter->last_dim_size_ = input->shape()[input->shape().size() - 1];
parameter->last_dim_size_ = input->shape().at(input->shape().size() - 1);
parameter->loop_num_ = 1;
for (size_t i = 0; i < input->shape().size() - 1; ++i) {
parameter->loop_num_ *= input->shape()[i];
parameter->loop_num_ *= input->shape().at(i);
}
return RET_OK;
}

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

@ -36,7 +36,7 @@ int TransposeCPUKernel::Init() {
int TransposeCPUKernel::ReSize() {
TransposeParameter *param = reinterpret_cast<TransposeParameter *>(op_parameter_);
num_unit_ = static_cast<int>(in_tensors_[kInputIndex]->shape().at(param->perm_[kNHWC_H]));
num_unit_ = static_cast<int>(in_tensors_.at(kInputIndex)->shape().at(param->perm_[kNHWC_H]));
thread_h_num_ = MSMIN(thread_num_, num_unit_);
thread_h_stride_ = UP_DIV(num_unit_, thread_h_num_);
@ -48,8 +48,8 @@ int TransposeCPUKernel::ReSize() {
param->out_strides_[param->num_axes_ - 1] = 1;
param->data_size_ = inTensor->Size();
for (int i = param->num_axes_ - 2; i >= 0; i--) {
param->strides_[i] = in_shape[i + 1] * param->strides_[i + 1];
param->out_strides_[i] = out_shape[i + 1] * param->out_strides_[i + 1];
param->strides_[i] = in_shape.at(i + 1) * param->strides_[i + 1];
param->out_strides_[i] = out_shape.at(i + 1) * param->out_strides_[i + 1];
}
if (this->in_shape_ != nullptr) {
free(this->in_shape_);

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

@ -39,7 +39,7 @@ int UniqueCPUKernel::Run() {
Unique(input, in_tensors_.at(0)->ElementsNum(), output0, &output0_len, output1);
std::vector<int> out_shape = out_tensors_.at(0)->shape();
out_shape[out_shape.size() - 1] = output0_len;
out_shape.at(out_shape.size() - 1) = output0_len;
out_tensors_.at(0)->set_shape(out_shape);
return RET_OK;
}

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

@ -44,8 +44,8 @@ int UpsampleCPUKernel::ReSize() {
MS_LOG(ERROR) << "Upsample out tensor dim should be 4";
return RET_ERROR;
}
new_height_ = out_shape[1];
new_width_ = out_shape[2];
new_height_ = out_shape.at(1);
new_width_ = out_shape.at(2);
if (param_->method_ == 0) { // bilinear
FreeTmpBuffer();
@ -96,12 +96,12 @@ int UpsampleCPUKernel::RunImpl(int task_id) {
switch (param_->method_) {
case static_cast<int>(schema::ResizeMethod_LINEAR): {
int n_h_begin, n_h_end;
int n = out_tensor->shape()[0];
int n = out_tensor->shape().at(0);
int h = new_height_;
int unit = UP_DIV(n * h, context_->thread_num_);
n_h_begin = unit * task_id;
n_h_end = std::min(n_h_begin + unit, n * h);
int c = in_tensors_.at(0)->shape()[3];
int c = in_tensors_.at(0)->shape().at(3);
float *line0 = line_buffer_ + new_width_ * c * 2 * task_id;
float *line1 = line0 + new_width_ * c;
ret =

18
mindspore/lite/src/runtime/kernel/arm/fp32_grad/sgd.cc
View File

@ -33,13 +33,13 @@ namespace mindspore::kernel {
int SgdCPUKernel::ReSize() { return RET_OK; }
int SgdCPUKernel::Execute(int task_id) {
auto weight = reinterpret_cast<float *>(in_tensors_[0]->MutableData());
auto accumulate = reinterpret_cast<float *>(in_tensors_[3]->MutableData());
float learning_rate = reinterpret_cast<float *>(in_tensors_[2]->MutableData())[0];
auto gradient = reinterpret_cast<float *>(in_tensors_[1]->MutableData());
float moment = reinterpret_cast<float *>(in_tensors_[4]->MutableData())[0];
size_t elem_num = in_tensors_[0]->ElementsNum();
auto stat = reinterpret_cast<float *>(in_tensors_[5]->MutableData());
auto weight = reinterpret_cast<float *>(in_tensors_.at(0)->MutableData());
auto accumulate = reinterpret_cast<float *>(in_tensors_.at(3)->MutableData());
float learning_rate = reinterpret_cast<float *>(in_tensors_.at(2)->MutableData())[0];
auto gradient = reinterpret_cast<float *>(in_tensors_.at(1)->MutableData());
float moment = reinterpret_cast<float *>(in_tensors_.at(4)->MutableData())[0];
size_t elem_num = in_tensors_.at(0)->ElementsNum();
auto stat = reinterpret_cast<float *>(in_tensors_.at(5)->MutableData());
if (stat[0] > 0) {
stat[0] = 0;
@ -96,8 +96,8 @@ int SgdCPUKernel::Run() {
int SgdCPUKernel::Init() {
// Only for test with uninitialized Data
size_t elem_num = in_tensors_[0]->ElementsNum();
auto accumulate = reinterpret_cast<float *>(in_tensors_[3]->MutableData());
size_t elem_num = in_tensors_.at(0)->ElementsNum();
auto accumulate = reinterpret_cast<float *>(in_tensors_.at(3)->MutableData());
for (size_t i = 0; i < elem_num; i++) {
accumulate[i] = 0.0;
}

12
mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_cross_entropy_with_logits.cc
View File

@ -101,11 +101,11 @@ int SoftmaxCrossEntropyWithLogitsCPUKernel::Run() {
}
int SoftmaxCrossEntropyWithLogitsCPUKernel::Init() {
auto dims = in_tensors_[0]->shape();
auto dims = in_tensors_.at(0)->shape();
param_->n_dim_ = 2;
param_->number_of_classes_ = dims[1];
param_->batch_size_ = dims[0];
for (unsigned int i = 0; i < dims.size(); i++) param_->input_shape_[i] = dims[i];
param_->number_of_classes_ = dims.at(1);
param_->batch_size_ = dims.at(0);
for (unsigned int i = 0; i < dims.size(); i++) param_->input_shape_[i] = dims.at(i);
if (this->in_tensors_.size() != 2) {
MS_LOG(ERROR) << "softmax entropy loss should have two inputs";
return RET_ERROR;
@ -117,11 +117,11 @@ int SoftmaxCrossEntropyWithLogitsCPUKernel::Init() {
}
size_t data_size = in_tensors_.at(0)->ElementsNum();
set_workspace_size((data_size + dims[0]) * sizeof(float));
set_workspace_size((data_size + dims.at(0)) * sizeof(float));
sm_params_.n_dim_ = 2;
sm_params_.element_size_ = data_size;
sm_params_.axis_ = 1;
for (size_t i = 0; i < dims.size(); i++) sm_params_.input_shape_[i] = dims[i];
for (size_t i = 0; i < dims.size(); i++) sm_params_.input_shape_[i] = dims.at(i);
return RET_OK;
}

8
mindspore/lite/src/runtime/kernel/arm/fp32_grad/softmax_grad.cc
View File

@ -35,8 +35,8 @@ int SoftmaxGradCPUKernel::Init() {
int ele_size = 1;
param->n_dim_ = in_dims;
for (size_t i = 0; i < in_dims; i++) {
param->input_shape_[i] = in_shape[i];
ele_size *= in_shape[i];
param->input_shape_[i] = in_shape.at(i);
ele_size *= in_shape.at(i);
}
param->element_size_ = ele_size;
@ -50,9 +50,9 @@ int SoftmaxGradCPUKernel::Init() {
inner_size_ = 1;
for (size_t i = axis + 1; i < in_dims; i++) {
inner_size_ *= in_shape[i];
inner_size_ *= in_shape.at(i);
}
set_workspace_size(inner_size_ * (1 + in_shape[axis]) * sizeof(float));
set_workspace_size(inner_size_ * (1 + in_shape.at(axis)) * sizeof(float));
return RET_OK;
}

12
mindspore/lite/src/runtime/kernel/arm/fp32_grad/sparse_softmax_cross_entropy_with_logits.cc
View File

@ -121,11 +121,11 @@ int SparseSoftmaxCrossEntropyWithLogitsCPUKernel::Run() {
}
int SparseSoftmaxCrossEntropyWithLogitsCPUKernel::Init() {
auto dims = in_tensors_[0]->shape();
auto dims = in_tensors_.at(0)->shape();
param->n_dim_ = 2;
param->number_of_classes_ = dims[1];
param->batch_size_ = dims[0];
for (unsigned int i = 0; i < dims.size(); i++) param->input_shape_[i] = dims[i];
param->number_of_classes_ = dims.at(1);
param->batch_size_ = dims.at(0);
for (unsigned int i = 0; i < dims.size(); i++) param->input_shape_[i] = dims.at(i);
if (2 != this->in_tensors_.size()) {
MS_LOG(ERROR) << "sparse softmax entropy loss should have two inputs";
return RET_ERROR;
@ -136,11 +136,11 @@ int SparseSoftmaxCrossEntropyWithLogitsCPUKernel::Init() {
return RET_ERROR;
}
size_t data_size = in_tensors_.at(0)->ElementsNum();
set_workspace_size((data_size + dims[0]) * sizeof(float));
set_workspace_size((data_size + dims.at(0)) * sizeof(float));
sm_params_.n_dim_ = 2;
sm_params_.element_size_ = data_size;
sm_params_.axis_ = 1;
for (size_t i = 0; i < dims.size(); i++) sm_params_.input_shape_[i] = dims[i];
for (size_t i = 0; i < dims.size(); i++) sm_params_.input_shape_[i] = dims.at(i);
return RET_OK;
}

12
mindspore/lite/src/runtime/kernel/arm/int8/resize_int8.cc
View File

@ -96,32 +96,32 @@ int ResizeInt8CPUKernel::Init() {
int ResizeInt8CPUKernel::InitResizeQuantArg() {
auto out_shape = out_tensors_.front()->shape();
resize_quant_arg_.x_axis_index_ = reinterpret_cast<int32_t *>(malloc(out_shape[2] * sizeof(int32_t)));
resize_quant_arg_.x_axis_index_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(2) * sizeof(int32_t)));
if (resize_quant_arg_.x_axis_index_ == nullptr) {
MS_LOG(ERROR) << "malloc x axis index array failed.";
return RET_ERROR;
}
resize_quant_arg_.x_axis_lower_ = reinterpret_cast<int32_t *>(malloc(out_shape[2] * sizeof(int32_t)));
resize_quant_arg_.x_axis_lower_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(2) * sizeof(int32_t)));
if (resize_quant_arg_.x_axis_lower_ == nullptr) {
MS_LOG(ERROR) << "malloc x_axis_lower_ array failed.";
return RET_ERROR;
}
resize_quant_arg_.x_axis_upper_ = reinterpret_cast<int32_t *>(malloc(out_shape[2] * sizeof(int32_t)));
resize_quant_arg_.x_axis_upper_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(2) * sizeof(int32_t)));
if (resize_quant_arg_.x_axis_upper_ == nullptr) {
MS_LOG(ERROR) << "malloc x_axis_upper_ array failed.";
return RET_ERROR;
}
resize_quant_arg_.y_axis_index_ = reinterpret_cast<int32_t *>(malloc(out_shape[1] * sizeof(int32_t)));
resize_quant_arg_.y_axis_index_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(1) * sizeof(int32_t)));
if (resize_quant_arg_.y_axis_index_ == nullptr) {
MS_LOG(ERROR) << "malloc y_axis_index_ array failed.";
return RET_ERROR;
}
resize_quant_arg_.y_axis_lower_ = reinterpret_cast<int32_t *>(malloc(out_shape[1] * sizeof(int32_t)));
resize_quant_arg_.y_axis_lower_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(1) * sizeof(int32_t)));
if (resize_quant_arg_.y_axis_lower_ == nullptr) {
MS_LOG(ERROR) << "malloc y_axis_lower_ array failed.";
return RET_ERROR;
}
resize_quant_arg_.y_axis_upper_ = reinterpret_cast<int32_t *>(malloc(out_shape[1] * sizeof(int32_t)));
resize_quant_arg_.y_axis_upper_ = reinterpret_cast<int32_t *>(malloc(out_shape.at(1) * sizeof(int32_t)));
if (resize_quant_arg_.y_axis_upper_ == nullptr) {
MS_LOG(ERROR) << "malloc y_axis_upper_ array failed.";
return RET_ERROR;

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

@ -141,10 +141,10 @@ int ScaleInt8CPUKernel::InitParameter() {
second_in_shape_.resize(len);
size_t i = 0;
for (; i < input1_size; ++i) {
second_in_shape_[i] = input1_shape[i];
second_in_shape_.at(i) = input1_shape.at(i);
}
for (; i < len; ++i) {
second_in_shape_[i] = 1;
second_in_shape_.at(i) = 1;
}
input1_size = len;
}
@ -164,7 +164,7 @@ int ScaleInt8CPUKernel::InitParameter() {
if (i < fill_dim_num) {
tile_para->in_shape1_[i] = 1;
} else {
tile_para->in_shape1_[i] = second_in_shape_[j++];
tile_para->in_shape1_[i] = second_in_shape_.at(j++);
}
tile_para->out_shape_[i] = out_tensors_.at(0)->DimensionSize(i);
}

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

@ -51,9 +51,9 @@ int SliceInt8CPUKernel::Init() {
}
int SliceInt8CPUKernel::DoSlice(int task_id) {
const int8_t *input_data = reinterpret_cast<const int8_t *>(in_tensors_[0]->MutableData());
const int8_t *input_data = reinterpret_cast<const int8_t *>(in_tensors_.at(0)->MutableData());
MS_ASSERT(input_data);
int8_t *output_data = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
int8_t *output_data = reinterpret_cast<int8_t *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_data);
auto ret = SliceInt8(input_data, output_data, param_, task_id);
@ -73,9 +73,9 @@ int SliceInt8Run(void *cdata, int task_id) {
}
int SliceInt8CPUKernel::Run() {
const int8_t *input_data = reinterpret_cast<const int8_t *>(in_tensors_[0]->MutableData());
const int8_t *input_data = reinterpret_cast<const int8_t *>(in_tensors_.at(0)->MutableData());
MS_ASSERT(input_data);
int8_t *output_data = reinterpret_cast<int8_t *>(out_tensors_[0]->MutableData());
int8_t *output_data = reinterpret_cast<int8_t *>(out_tensors_.at(0)->MutableData());
MS_ASSERT(output_data);
mindspore::lite::STATUS ret = RET_ERROR;
if (param_->size_[1] < param_->op_parameter_.thread_num_) {

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

@ -36,10 +36,10 @@ int TopKInt8CPUKernel::ReSize() {
MS_ASSERT(parameter);
lite::Tensor *input = in_tensors_.at(0);
MS_ASSERT(input);
parameter->last_dim_size_ = input->shape()[input->shape().size() - 1];
parameter->last_dim_size_ = input->shape().at(input->shape().size() - 1);
parameter->loop_num_ = 1;
for (size_t i = 0; i < input->shape().size() - 1; ++i) {
parameter->loop_num_ *= input->shape()[i];
parameter->loop_num_ *= input->shape().at(i);
}
return RET_OK;
}

Some files were not shown because too many files have changed in this diff Show More