diff --git a/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.cc b/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.cc index edcf2181874..e3090c81b6d 100644 --- a/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.cc +++ b/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.cc @@ -62,7 +62,8 @@ void FractionalMaxPoolCpuKernelMod::InitKernel(const CNodePtr &kernel_node) { << "', the size of parameter 'pooling_ratio' must be 4, but got " << pooling_ratio_.size() << "."; } - if (pooling_ratio_[kPoolingRatioIndex0] != 1.0 || pooling_ratio_[kPoolingRatioIndex3] != 1.0) { + if (!common::IsFloatEqual(pooling_ratio_[kPoolingRatioIndex0], 1.0) || + !common::IsFloatEqual(pooling_ratio_[kPoolingRatioIndex3], 1.0)) { MS_EXCEPTION(ValueError) << "For '" << kernel_name_ << "', the first and last elements of parameter 'pooling_ratio' must be 1.0."; } @@ -89,19 +90,19 @@ static std::vector GeneratePoolingSequencePseudoRandom(size_t input_len } else { // generate random number u which is in (0,1) double alpha = static_cast(input_length) / output_length; - int k = input_length / output_length; + int k = SizeToInt(input_length / output_length); double u_max1 = (k + 2) / alpha - 1; - if ((alpha - (output_length - 1)) == 0) { + if (common::IsDoubleEqual(alpha, LongToDouble(output_length - 1))) { MS_EXCEPTION(ValueError) << "For FractionalAvgPool, the input_length and output_length is wrong, please check " "the parameter 'pooling ratio'."; } else { - double u_max2 = (input_length + 1 - k) / alpha - (output_length - 1); + double u_max2 = (input_length + 1 - IntToSize(k)) / alpha - (output_length - 1); double max_u = std::min(u_max1, u_max2); std::default_random_engine random(seed); std::uniform_real_distribution dis2(0.0, 1.0); const double u = dis2(random) * max_u; cum_seq[0] = 1; - cum_seq[output_length] = input_length + 1; + cum_seq[output_length] = SizeToLong(input_length + 1); for (size_t i = 1; i < output_length; ++i) { cum_seq[i] = static_cast(ceil(alpha * (i + u))); } @@ -117,7 +118,7 @@ static std::vector GeneratePoolingSequenceRandom(size_t input_length, s if (output_length == 0) { MS_EXCEPTION(ValueError) << "For FractionalAvgPool, output_length got 0, please check it."; } else { - int k = input_length / output_length; + int k = SizeToInt(input_length / output_length); size_t num_random_spot = input_length % output_length; std::vector diff(output_length, k); for (size_t i = 0; i < num_random_spot; ++i) { @@ -138,14 +139,14 @@ std::vector GeneratePoolingSequence(int64_t input_length, int64_t outpu diff = std::vector(output_length, input_length / output_length); } else { if (pseudo_random) { - diff = GeneratePoolingSequencePseudoRandom(input_length, output_length, seed); + diff = GeneratePoolingSequencePseudoRandom(LongToSize(input_length), LongToSize(output_length), seed); } else { - diff = GeneratePoolingSequenceRandom(input_length, output_length, seed); + diff = GeneratePoolingSequenceRandom(LongToSize(input_length), LongToSize(output_length), seed); } } - int k = input_length / output_length; + int k = LongToInt(input_length / output_length); for (size_t i = 0; i < LongToSize(output_length); i++) { - if (diff[i] < k || diff[i] > k + 1) { + if (diff[i] < k || diff[i] > IntToLong(k) + 1) { MS_EXCEPTION(ValueError) << "For FractionalAvgPool, GeneratePoolingSequence diff[" << i << "] is error"; } } @@ -160,13 +161,13 @@ std::vector GeneratePoolingSequence(int64_t input_length, int64_t outpu template bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolLaunch(const std::vector &inputs, const std::vector &outputs) { - T *input_ptr = reinterpret_cast(inputs[0]->addr); + T *input_ptr = static_cast(inputs[0]->addr); MS_EXCEPTION_IF_NULL(input_ptr); - T *output_ptr = reinterpret_cast(outputs[0]->addr); + T *output_ptr = static_cast(outputs[0]->addr); MS_EXCEPTION_IF_NULL(output_ptr); - int64_t *row_pooling_sequence_ptr = reinterpret_cast(outputs[1]->addr); + int64_t *row_pooling_sequence_ptr = static_cast(outputs[1]->addr); MS_EXCEPTION_IF_NULL(row_pooling_sequence_ptr); - int64_t *col_pooling_sequence_ptr = reinterpret_cast(outputs[2]->addr); + int64_t *col_pooling_sequence_ptr = static_cast(outputs[2]->addr); MS_EXCEPTION_IF_NULL(col_pooling_sequence_ptr); for (size_t i = 0; i < kInputDims; i++) { output_shape_[i] = static_cast(std::floor(input_shape_[i] / pooling_ratio_[i])); @@ -181,8 +182,8 @@ bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolLaunch(const std::vector -bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolDoCompute(T *input_ptr, T *output_ptr, size_t b, size_t hs, +bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolDoCompute(const T *input_ptr, T *output_ptr, size_t b, size_t hs, const int64_t height_start, int64_t height_end, std::vector width_cum_seq) { const int64_t width_max = input_shape_[kInputShapeIndexW] - 1; @@ -232,9 +233,11 @@ bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolDoCompute(T *input_ptr, T * // width sequence. for (size_t ws = 0; ws < width_cum_seq.size() - 1; ++ws) { for (int64_t c = 0; c <= depth_max; ++c) { - const int64_t out_offset = ((b * output_shape_[kInputShapeIndexH] + hs) * output_shape_[kInputShapeIndexW] + ws) * - output_shape_[kInputShapeIndexC] + - c; + const int64_t out_offset = + ((SizeToLong(b) * output_shape_[kInputShapeIndexH] + SizeToLong(hs)) * output_shape_[kInputShapeIndexW] + + SizeToLong(ws)) * + output_shape_[kInputShapeIndexC] + + c; // Initializes the output tensor with MIN. T max = std::numeric_limits::lowest(); // width start and end. @@ -243,9 +246,10 @@ bool FractionalMaxPoolCpuKernelMod::FractionalMaxPoolDoCompute(T *input_ptr, T * width_end = std::min(width_end, width_max); for (int64_t h = height_start; h <= height_end; ++h) { for (int64_t w = width_start; w <= width_end; ++w) { - const int64_t in_offset = ((b * input_shape_[kInputShapeIndexH] + h) * input_shape_[kInputShapeIndexW] + w) * - output_shape_[kInputShapeIndexC] + - c; + const int64_t in_offset = + ((SizeToLong(b) * input_shape_[kInputShapeIndexH] + h) * input_shape_[kInputShapeIndexW] + w) * + output_shape_[kInputShapeIndexC] + + c; max = max > *(input_ptr + in_offset) ? max : *(input_ptr + in_offset); } } @@ -283,8 +287,8 @@ std::vector FractionalMaxPoolCpuKernelMod::GetOpSupport() { std::vector support_list; - std::transform(func_list_.begin(), func_list_.end(), std::back_inserter(support_list), - [](const std::pair &pair) { return pair.first; }); + (void)std::transform(func_list_.begin(), func_list_.end(), std::back_inserter(support_list), + [](const std::pair &pair) { return pair.first; }); return support_list; } diff --git a/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.h b/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.h index 16730389bfc..0bfe87e35f4 100644 --- a/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.h +++ b/mindspore/ccsrc/plugin/device/cpu/kernel/fractional_max_pool_cpu_kernel.h @@ -35,7 +35,7 @@ class FractionalMaxPoolCpuKernelMod : public DeprecatedNativeCpuKernelMod { ~FractionalMaxPoolCpuKernelMod() override = default; void InitKernel(const CNodePtr &kernel_node) override; - bool Launch(const std::vector &inputs, const std::vector &workspace, + bool Launch(const std::vector &inputs, const std::vector &, const std::vector &outputs) override { return kernel_func_(this, inputs, outputs); } @@ -46,7 +46,7 @@ class FractionalMaxPoolCpuKernelMod : public DeprecatedNativeCpuKernelMod { template bool FractionalMaxPoolLaunch(const std::vector &inputs, const std::vector &outputs); template - bool FractionalMaxPoolDoCompute(T *input_ptr, T *output_ptr, size_t b, size_t hs, const int64_t height_start, + bool FractionalMaxPoolDoCompute(const T *input_ptr, T *output_ptr, size_t b, size_t hs, const int64_t height_start, int64_t height_end, std::vector width_cum_seq); using FractionalMaxPoolFunc = std::function &, const std::vector &)>;