m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

code clean

Browse Source
pull/6567/head
liuzhongkai 5 years ago
parent 47264cbffd
commit 37567147bd
15 changed files with 64 additions and 26 deletions
Show Stats Download Patch File Download Diff File

13
mindspore/lite/nnacl/fp16/pooling_fp16.c
Unescape View File

@ -15,8 +15,9 @@
*/
#include "nnacl/fp16/pooling_fp16.h"
#include <float.h>
#include "nnacl/errorcode.h"
void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int stride_w = pooling_param->stride_w_;
int stride_h = pooling_param->stride_h_;
int pad_w = pooling_param->pad_l_;
@ -83,6 +84,9 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
if (pooling_param->avg_mode_ == 1) {
real_count = window;
}
if (real_count == 0) {
return NNACL_ERR;
}
#ifdef ENABLE_NEON
vst1q_f16(output_ptr + out_channel_offset, tmp_avg / vdupq_n_f16(real_count));
#else
@ -118,6 +122,9 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
if (pooling_param->avg_mode_ == 1) {
real_count = window;
}
if (real_count == 0) {
return NNACL_ERR;
}
#ifdef ENABLE_NEON
vst1_f16(output_ptr + out_channel_offset, tmp_avg / vdup_n_f16(real_count));
#else
@ -140,11 +147,15 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
++real_count;
} // win_w loop
} // win_h loop
if (real_count == 0) {
return NNACL_ERR;
}
*(output_ptr + out_channel_offset) = tmp_avg / (float16_t)real_count;
} // channel_res loop
} // real_cal_num loop
} // out_plane loop
} // out_batch loop
return NNACL_OK;
}
void MaxPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {

2
mindspore/lite/nnacl/fp16/pooling_fp16.h
Unescape View File

@ -24,7 +24,7 @@
#ifdef __cplusplus
extern "C" {
#endif
void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
int AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
void MaxPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
#ifdef __cplusplus

10
mindspore/lite/nnacl/fp32/pooling.c
Unescape View File

@ -16,8 +16,9 @@
#include "nnacl/fp32/pooling.h"
#include <float.h>
#include "nnacl/errorcode.h"
void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
int AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
float maxf) {
int stride_w = pooling_param->stride_w_;
int stride_h = pooling_param->stride_h_;
@ -92,6 +93,9 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
if (pooling_param->avg_mode_ == 1) {
real_count = window;
}
if (real_count == 0) {
return NNACL_ERR;
}
#ifdef ENABLE_NEON
tmp_avg = tmp_avg / vdupq_n_f32(real_count);
tmp_avg = vmaxq_f32(tmp_avg, min_value);
@ -132,6 +136,9 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
if (pooling_param->avg_mode_ == 1) {
real_count = window;
}
if (real_count == 0) {
return NNACL_ERR;
}
tmp_avg = tmp_avg / (float)real_count;
tmp_avg = fmax(tmp_avg, minf);
tmp_avg = fmin(tmp_avg, maxf);
@ -140,6 +147,7 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
} // real_cal_num loop
} // out_plane loop
} // out_batch loop
return NNACL_OK;
}
void MaxPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,

2
mindspore/lite/nnacl/fp32/pooling.h
Unescape View File

@ -27,7 +27,7 @@
#ifdef __cplusplus
extern "C" {
#endif
void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
int AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
float maxf);
void MaxPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
float maxf);

13
mindspore/lite/nnacl/int8/pooling_int8.c
Unescape View File

@ -16,8 +16,9 @@
#include "nnacl/int8/pooling_int8.h"
#include "nnacl/common_func.h"
#include "nnacl/errorcode.h"
void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int stride_w = pooling_param->stride_w_;
int stride_h = pooling_param->stride_h_;
int pad_w = pooling_param->pad_l_;
@ -64,6 +65,9 @@ void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParamete
}
} // win_w loop
} // win_h loop
if (real_count == 0) {
return NNACL_ERR;
}
int16_t tmp_out = round((float)tmp_avg / (float)real_count);
tmp_out = (int8_t)(round((tmp_out - input_zp) * real_multiplier) + output_zp);
int8_t real_out = tmp_out < out_min ? out_min : tmp_out;
@ -72,9 +76,10 @@ void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParamete
} // in_channel loop
} // out_plane loop
} // out_batch loop
return NNACL_OK;
}
void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
int stride_w = pooling_param->stride_w_;
int stride_h = pooling_param->stride_h_;
int pad_w = pooling_param->pad_l_;
@ -118,6 +123,9 @@ void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParam
int kh_s = MSMAX(0, -in_h_index);
int kh_e = MSMIN(win_h, in_h - in_h_index);
int real_count = (kw_e - kw_s) * (kh_e - kh_s);
if (real_count == 0) {
return NNACL_ERR;
}
// 16 channels
for (int j = 0; j < c16; j++) {
@ -272,6 +280,7 @@ void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParam
} // out_plane loop
} // out_batch loop
}
return NNACL_OK;
}
void MaxPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {

4
mindspore/lite/nnacl/int8/pooling_int8.h
Unescape View File

@ -26,9 +26,9 @@
#ifdef __cplusplus
extern "C" {
#endif
void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
int AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
int AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
void MaxPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);

6
mindspore/lite/nnacl/minimal_filtering_generator.c
Unescape View File

@ -33,8 +33,8 @@ void Polynomial(float *interval, float *m, int degree) {
void DiagonalPlusMatrix(float *matrix, float *diagonal_matrix, int degree) {
int data_num = (degree + 1) * (degree + 1);
memset(diagonal_matrix, 0, data_num * sizeof(float));
for (int i = 0; i < (degree + 1); ++i) {
for (int j = 0; j < (degree + 1); ++j) {
for (int i = 0; i < degree; ++i) {
for (int j = 0; j < degree; ++j) {
if (j == i) diagonal_matrix[i * (degree + 1) + j] = matrix[i];
}
}
@ -156,7 +156,7 @@ int CookToomFilter(float *matrix_a, float *matrix_at, float *matrix_b, float *ma
float *matrix_gt, float coefficient, int out_unit, int filter_size) {
int in_unit = out_unit + filter_size - 1;
int degree = in_unit - 1;
if (degree > MAX_LEN || (in_unit * in_unit) > MAX_LEN || degree > MAX_LEN || (in_unit * filter_size) > MAX_LEN) {
if (degree > MAX_LEN || (in_unit * in_unit) > MAX_LEN || (in_unit * filter_size) > MAX_LEN) {
return NNACL_ERR;
}
float polynomial_m[MAX_LEN]; // degree

4
mindspore/lite/nnacl/winograd_transform.c
Unescape View File

@ -351,11 +351,11 @@ void Conv3x3Fp32InputTransform(const float *input_data, float *trans_input, floa
void Conv3x3Fp32FilterTransform(float *weight_data, float *trans_weight, int iC4, int output_channel, int kernel_plane,
int oc_block) {
int oc_plane_block = UP_DIV(output_channel, oc_block);
int dst_step = iC4 * C4NUM * oc_block * oc_plane_block;
if (oc_block == 0) {
return;
}
int oc_plane_block = UP_DIV(output_channel, oc_block);
int dst_step = iC4 * C4NUM * oc_block * oc_plane_block;
for (int o = 0; o < output_channel; o++) {
int oc_block_num = o / oc_block;
int oc_block_rem = o % oc_block;

12
mindspore/lite/nnacl/winograd_utils.c
Unescape View File

@ -361,12 +361,12 @@ void InputTransform8x8Unit(const float *src_data, float *dst_data, int src_step,
}
OutputTransFunc GetOutputTransFunc(int input_unit, int output_unit) {
if (input_unit == 4) {
return OutputTransFuncList4[output_unit];
} else if (input_unit == 6) {
return OutputTransFuncList6[output_unit];
} else if (input_unit == 8) {
return OutputTransFuncList8[output_unit];
if (input_unit == 4 && output_unit < 4) {
return OutputTransFuncList4[output_unit];
} else if (input_unit == 6 && output_unit < 6) {
return OutputTransFuncList6[output_unit];
} else if (input_unit == 8 && output_unit < 8) {
return OutputTransFuncList8[output_unit];
} else {
return NULL;
}

1
mindspore/lite/src/lite_session.cc
Unescape View File

@ -91,6 +91,7 @@ int LiteSession::ConvertTensors(const lite::Model *model) {
auto dst_data = dstTensor->MutableData();
if (dst_data == nullptr) {
MS_LOG(ERROR) << "MutableData from " << i << "th tensor is nullptr";
free(dstTensor);
return RET_ERROR;
}
memcpy(dst_data, srcTensor->data()->data(), dstTensor->Size());

1
mindspore/lite/src/model.cc
Unescape View File

@ -34,6 +34,7 @@ bool ConvertNodes(const schema::MetaGraph *meta_graph, Model *model) {
node->primitive_ = PrimitiveC::Create(const_cast<schema::Primitive *>(src_prim));
if (node->primitive_ == nullptr) {
MS_LOG(ERROR) << "unpack primitive == nullptr!";
free(node);
return false;
}
node->primitive_->SetQuantType(c_node->quantType());

4
mindspore/lite/src/ops/depend.cc
Unescape View File

@ -40,10 +40,6 @@ int Depend::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inp
return RET_ERROR;
}
this->primitive_->value.value = attr;
if (this->primitive_->value.value == nullptr) {
MS_LOG(ERROR) << "primitive value is nullptr";
return RET_ERROR;
}
}
return RET_OK;
}

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

@ -56,7 +56,11 @@ int PoolingFp16CPUKernel::RunImpl(int task_id) {
if (pooling_param_->pool_mode_ == PoolMode_MaxPool) {
MaxPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
} else {
AvgPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
auto ret = AvgPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
if (ret != RET_OK) {
MS_LOG(ERROR) << "AvgPooling run failed.";
return ret;
}
}
return RET_OK;
}

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

@ -64,7 +64,11 @@ int PoolingCPUKernel::RunImpl(int task_id) {
if (pooling_param_->pool_mode_ == PoolMode_MaxPool) {
MaxPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
} else {
AvgPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
auto ret = AvgPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
if (ret != RET_OK) {
MS_LOG(ERROR) << "AcgPooling run failed.";
return ret;
}
}
return RET_OK;
}

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

@ -68,7 +68,11 @@ int PoolingInt8CPUKernel::RunImpl(int task_id) {
MaxPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
}
} else {
AvgPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
auto ret = AvgPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
if (ret != RET_OK) {
MS_LOG(ERROR) << "AvgPooling run failed.";
return ret;
}
}
return RET_OK;
}

Write Preview
Loading…
Cancel
Save