| /* | |
| * Copyright (c) 2017-2020, 2023 Arm Limited. | |
| * | |
| * SPDX-License-Identifier: MIT | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a copy | |
| * of this software and associated documentation files (the "Software"), to | |
| * deal in the Software without restriction, including without limitation the | |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | |
| * sell copies of the Software, and to permit persons to whom the Software is | |
| * furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included in all | |
| * copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
| * SOFTWARE. | |
| */ | |
| #include "ReductionOperation.h" | |
| #include "tests/validation/Helpers.h" | |
| #include <algorithm> | |
| #include <cmath> | |
| namespace arm_compute | |
| { | |
| namespace test | |
| { | |
| namespace validation | |
| { | |
| namespace reference | |
| { | |
| namespace | |
| { | |
| template <typename T, typename OT> | |
| OT reduce_operation(const T *ptr, int reduce_elements, ReductionOperation op, int stride, RoundingPolicy policy) | |
| { | |
| using type = typename std::remove_cv<OT>::type; | |
| T res; | |
| switch(op) | |
| { | |
| case ReductionOperation::PROD: | |
| { | |
| res = type(1); | |
| } | |
| break; | |
| case ReductionOperation::MIN: | |
| case ReductionOperation::MAX: | |
| { | |
| res = *ptr; | |
| } | |
| break; | |
| default: | |
| { | |
| res = type(0); | |
| } | |
| } | |
| if(std::is_integral<type>::value) | |
| { | |
| auto int_res = static_cast<int32_t>(res); | |
| for(int i = 0; i < reduce_elements; ++i) | |
| { | |
| auto elem = *(ptr + stride * i); | |
| switch(op) | |
| { | |
| case ReductionOperation::MIN: | |
| if(static_cast<T>(int_res) > elem) | |
| { | |
| int_res = elem; | |
| } | |
| break; | |
| case ReductionOperation::MAX: | |
| if(static_cast<T>(int_res) < elem) | |
| { | |
| int_res = elem; | |
| } | |
| break; | |
| case ReductionOperation::SUM_SQUARE: | |
| int_res += elem * elem; | |
| break; | |
| case ReductionOperation::MEAN_SUM: | |
| case ReductionOperation::SUM: | |
| int_res += elem; | |
| break; | |
| case ReductionOperation::PROD: | |
| int_res *= elem; | |
| break; | |
| default: | |
| ARM_COMPUTE_ERROR("Operation not supported"); | |
| } | |
| } | |
| if(op == ReductionOperation::MEAN_SUM && reduce_elements > 0) | |
| { | |
| // Only use rounding in aarch64 to be consistent with kernel | |
| #ifdef __aarch64__ | |
| // Divide in float format, then rounded to nearest and implicitly cast back to int | |
| int_res = round(static_cast<float>(int_res) / static_cast<float>(reduce_elements), policy); | |
| #else // defined(__aarch64__) | |
| ARM_COMPUTE_UNUSED(policy); | |
| int_res /= reduce_elements; // Legacy compatibility | |
| #endif // __aarch64 | |
| } | |
| res = static_cast<type>(int_res); | |
| } | |
| else | |
| { | |
| for(int i = 0; i < reduce_elements; ++i) | |
| { | |
| auto elem = *(ptr + stride * i); | |
| switch(op) | |
| { | |
| case ReductionOperation::MIN: | |
| if(res > elem) | |
| { | |
| res = elem; | |
| } | |
| break; | |
| case ReductionOperation::MAX: | |
| if(res < elem) | |
| { | |
| res = elem; | |
| } | |
| break; | |
| case ReductionOperation::SUM_SQUARE: | |
| res += elem * elem; | |
| break; | |
| case ReductionOperation::MEAN_SUM: | |
| case ReductionOperation::SUM: | |
| res += elem; | |
| break; | |
| case ReductionOperation::PROD: | |
| res *= elem; | |
| break; | |
| default: | |
| ARM_COMPUTE_ERROR("Operation not supported"); | |
| } | |
| } | |
| if(op == ReductionOperation::MEAN_SUM && reduce_elements > 0) | |
| { | |
| res /= reduce_elements; | |
| } | |
| } | |
| return res; | |
| } | |
| template <typename T, typename OT> | |
| OT reduce_operation_arg_min_max(const T *ptr, int reduce_elements, ReductionOperation op, int stride) | |
| { | |
| uint32_t res = 0; | |
| for(int i = 0; i < reduce_elements; ++i) | |
| { | |
| auto elem = *(ptr + stride * i); | |
| switch(op) | |
| { | |
| case ReductionOperation::ARG_IDX_MIN: | |
| if(*(ptr + stride * res) > elem) | |
| { | |
| res = static_cast<uint32_t>(i); | |
| } | |
| break; | |
| case ReductionOperation::ARG_IDX_MAX: | |
| if(*(ptr + stride * res) < elem) | |
| { | |
| res = static_cast<uint32_t>(i); | |
| } | |
| break; | |
| default: | |
| ARM_COMPUTE_ERROR("Operation not supported"); | |
| } | |
| } | |
| return static_cast<OT>(res); | |
| } | |
| } // namespace | |
| template <typename T, typename OT> | |
| SimpleTensor<OT> compute_reduction_operation(const SimpleTensor<T> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, RoundingPolicy policy) | |
| { | |
| // Create reference | |
| const bool is_arg_min_max = (op == ReductionOperation::ARG_IDX_MIN || op == ReductionOperation::ARG_IDX_MAX); | |
| DataType output_data_type = is_arg_min_max ? DataType::S32 : src.data_type(); | |
| SimpleTensor<OT> dst{ dst_shape, output_data_type, 1, src.quantization_info() }; | |
| const unsigned int src_width = src.shape().x(); | |
| const unsigned int src_height = src.shape().y(); | |
| const unsigned int src_depth = src.shape().z(); | |
| const unsigned int src_batch = src.shape()[3]; | |
| const int reduce_elems = src.shape()[axis]; | |
| switch(axis) | |
| { | |
| case 0: | |
| { | |
| const unsigned int upper_dims = src.shape().total_size_upper(1); | |
| for(unsigned int du = 0; du < upper_dims; ++du) | |
| { | |
| const T *src_row_ptr = src.data() + du * reduce_elems; | |
| dst[du] = is_arg_min_max ? | |
| reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, 1) : | |
| reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, 1, policy); | |
| } | |
| } | |
| break; | |
| case 1: | |
| { | |
| const unsigned int upper_dims = src.shape().total_size_upper(2); | |
| for(unsigned int du = 0; du < upper_dims; ++du) | |
| { | |
| for(unsigned int x = 0; x < src_width; ++x) | |
| { | |
| const int in_offset = du * src_height * src_width + x; | |
| const int out_offset = du * src_width + x; | |
| const T *src_row_ptr = src.data() + in_offset; | |
| dst[out_offset] = is_arg_min_max ? | |
| reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width) : | |
| reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width, policy); | |
| } | |
| } | |
| } | |
| break; | |
| case 2: | |
| { | |
| const unsigned int upper_dims = src.shape().total_size_upper(3); | |
| for(unsigned int du = 0; du < upper_dims; ++du) | |
| { | |
| for(unsigned int x = 0; x < src_width; ++x) | |
| { | |
| for(unsigned int y = 0; y < src_height; ++y) | |
| { | |
| const int in_offset = du * src_depth * src_height * src_width + y * src_width + x; | |
| const int out_offset = du * src_width * src_height + y * src_width + x; | |
| const T *src_row_ptr = src.data() + in_offset; | |
| dst[out_offset] = is_arg_min_max ? | |
| reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height) : | |
| reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height, policy); | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| case 3: | |
| { | |
| const unsigned int upper_dims = src.shape().total_size_upper(4); | |
| for(unsigned int du = 0; du < upper_dims; ++du) | |
| { | |
| for(unsigned int z = 0; z < src_depth; ++z) | |
| { | |
| for(unsigned int y = 0; y < src_height; ++y) | |
| { | |
| for(unsigned int x = 0; x < src_width; ++x) | |
| { | |
| const int in_offset = du * src_batch * src_depth * src_height * src_width + z * src_width * src_height + y * src_width + x; | |
| const int out_offset = du * src_depth * src_height * src_width + z * src_width * src_height + y * src_width + x; | |
| const T *src_row_ptr = src.data() + in_offset; | |
| dst[out_offset] = is_arg_min_max ? | |
| reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height * src_depth) : | |
| reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height * src_depth, policy); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| ARM_COMPUTE_ERROR("Unsupported reduction axis"); | |
| } | |
| return dst; | |
| } | |
| template <typename T, typename OT> | |
| SimpleTensor<OT> reduction_operation(const SimpleTensor<T> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, QuantizationInfo quantization_info_output, RoundingPolicy policy) | |
| { | |
| ARM_COMPUTE_UNUSED(quantization_info_output); | |
| return compute_reduction_operation<T, OT>(src, dst_shape, axis, op, policy); | |
| } | |
| template <> | |
| SimpleTensor<uint8_t> reduction_operation(const SimpleTensor<uint8_t> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, QuantizationInfo quantization_info_output, RoundingPolicy policy) | |
| { | |
| if(src.data_type() == DataType::QASYMM8) | |
| { | |
| // If the operation is MEAN_SUM, we can directly use the uint8 implementation without taking into account scale and offset | |
| if(op == ReductionOperation::MEAN_SUM && src.quantization_info() == quantization_info_output) | |
| { | |
| return compute_reduction_operation<uint8_t, uint8_t>(src, dst_shape, axis, op, policy); | |
| } | |
| else | |
| { | |
| SimpleTensor<float> src_f = convert_from_asymmetric(src); | |
| SimpleTensor<float> dst_f = reference::reduction_operation<float, float>(src_f, dst_shape, axis, op); | |
| return convert_to_asymmetric<uint8_t>(dst_f, quantization_info_output); | |
| } | |
| } | |
| else | |
| { | |
| return compute_reduction_operation<uint8_t, uint8_t>(src, dst_shape, axis, op, policy); | |
| } | |
| } | |
| template <> | |
| SimpleTensor<int8_t> reduction_operation(const SimpleTensor<int8_t> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, QuantizationInfo quantization_info_output, RoundingPolicy policy) | |
| { | |
| if(src.data_type() == DataType::QASYMM8_SIGNED) | |
| { | |
| // If the operation is MEAN_SUM, we can directly use the int8 implementation without taking into account scale and offset | |
| if(op == ReductionOperation::MEAN_SUM && src.quantization_info() == quantization_info_output) | |
| { | |
| return compute_reduction_operation<int8_t, int8_t>(src, dst_shape, axis, op, policy); | |
| } | |
| else | |
| { | |
| SimpleTensor<float> src_f = convert_from_asymmetric(src); | |
| SimpleTensor<float> dst_f = reference::reduction_operation<float, float>(src_f, dst_shape, axis, op); | |
| return convert_to_asymmetric<int8_t>(dst_f, quantization_info_output); | |
| } | |
| } | |
| else | |
| { | |
| return compute_reduction_operation<int8_t, int8_t>(src, dst_shape, axis, op, policy); | |
| } | |
| } | |
| template SimpleTensor<float> reduction_operation(const SimpleTensor<float> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<half> reduction_operation(const SimpleTensor<half> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<int32_t> reduction_operation(const SimpleTensor<float> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<int32_t> reduction_operation(const SimpleTensor<int32_t> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<int32_t> reduction_operation(const SimpleTensor<half> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<int32_t> reduction_operation(const SimpleTensor<uint8_t> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| template SimpleTensor<int32_t> reduction_operation(const SimpleTensor<int8_t> &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, | |
| QuantizationInfo quantization_info_output = QuantizationInfo(), RoundingPolicy policy = RoundingPolicy::TO_ZERO); | |
| } // namespace reference | |
| } // namespace validation | |
| } // namespace test | |
| } // namespace arm_compute |