From 48cfd5f7895f13167e4e9cd974dbc1e983e04ed7 Mon Sep 17 00:00:00 2001 From: Pablo Marquez Tello Date: Fri, 9 Jun 2023 11:22:29 +0100 Subject: Refactor activation LUT computation * Moving the code out of Types.h will help with the compilation time. * Added LUT support for all other activation functions. * Resolves COMPMID-6292 Change-Id: I1b5f0b21f03237447163276b8796b2aeb3fdd45c Signed-off-by: Pablo Marquez Tello Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/9749 Tested-by: Arm Jenkins Reviewed-by: Viet-Hoa Do Benchmark: Arm Jenkins --- arm_compute/core/QuantizationInfo.h | 62 -------------- arm_compute/core/Types.h | 107 +----------------------- src/cpu/kernels/CpuActivationKernel.cpp | 77 ++++++++++++++++- src/cpu/kernels/activation/generic/neon/lut.cpp | 2 +- src/cpu/kernels/activation/generic/sve2/lut.cpp | 2 +- tests/validation/NEON/ActivationLayer.cpp | 10 ++- 6 files changed, 85 insertions(+), 175 deletions(-) diff --git a/arm_compute/core/QuantizationInfo.h b/arm_compute/core/QuantizationInfo.h index 98ceec6c56..f760d7512c 100644 --- a/arm_compute/core/QuantizationInfo.h +++ b/arm_compute/core/QuantizationInfo.h @@ -399,68 +399,6 @@ inline float dequantize_qsymm8(int8_t value, const UniformQuantizationInfo &qinf return value * qinfo.scale; } -inline qasymm8_t qasymm8_hard_swish(qasymm8_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out) -{ - float tmp_f = dequantize_qasymm8(in, qi_in); - tmp_f = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f); - const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out); - return tmp; -} - -inline qasymm8_signed_t qasymm8_signed_hard_swish(qasymm8_signed_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out) -{ - float tmp_f = dequantize_qasymm8_signed(in, qi_in); - tmp_f = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f); - const qasymm8_t tmp = quantize_qasymm8_signed(tmp_f, qi_out); - return tmp; -} - -inline qasymm8_t qasymm8_leaky_relu(qasymm8_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out, - float alpha) -{ - float tmp_f = dequantize_qasymm8(in, qi_in); - tmp_f = tmp_f > 0 ? tmp_f : tmp_f * alpha; - const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out); - return tmp; -} - -inline qasymm8_signed_t qasymm8_signed_leaky_relu(qasymm8_signed_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out, - float alpha) -{ - float tmp_f = dequantize_qasymm8_signed(in, qi_in); - tmp_f = tmp_f > 0 ? tmp_f : tmp_f * alpha; - const qasymm8_t tmp = quantize_qasymm8_signed(tmp_f, qi_out); - return tmp; -} - -inline qasymm8_t qasymm8_logistic(qasymm8_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out) -{ - float tmp_f = dequantize_qasymm8(in, qi_in); - tmp_f = 1.f / (1.f + std::exp(-tmp_f)); - const qasymm8_t tmp = quantize_qasymm8(tmp_f, qi_out); - return tmp; -} - -inline qasymm8_signed_t qasymm8_signed_logistic(qasymm8_signed_t in, - const UniformQuantizationInfo &qi_in, - const UniformQuantizationInfo &qi_out) -{ - float tmp_f = dequantize_qasymm8_signed(in, qi_in); - tmp_f = 1.f / (1.f + std::exp(-tmp_f)); - const qasymm8_signed_t tmp = quantize_qasymm8_signed(tmp_f, qi_out); - return tmp; -} - /** Dequantize a value given a 8-bit symmetric quantization scheme * * @param[in] value Value to dequantize diff --git a/arm_compute/core/Types.h b/arm_compute/core/Types.h index 09b77b5a11..2613d46d14 100644 --- a/arm_compute/core/Types.h +++ b/arm_compute/core/Types.h @@ -1721,66 +1721,11 @@ public: { return _lut; } - - void init_lut(DataType data_type, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out) + void setLookupTable256(LookupTable256 &lut) { - if(_act == ActivationFunction::HARD_SWISH) - { - if(data_type == DataType::QASYMM8) - { - qasymm8_hard_swish_populate_table(_lut, qi_in, qi_out); - } - else - { - qasymm8_signed_hard_swish_populate_table(_lut, qi_in, qi_out); - } - } - else if(_act == ActivationFunction::LEAKY_RELU) - { - if(data_type == DataType::QASYMM8) - { - qasymm8_leaky_relu_populate_table(_lut, qi_in, qi_out, _a); - } - else - { - qasymm8_signed_leaky_relu_populate_table(_lut, qi_in, qi_out, _a); - } - } - else if(_act == ActivationFunction::LOGISTIC) - { - if(data_type == DataType::QASYMM8) - { - qasymm8_logistic_populate_table(_lut, qi_in, qi_out); - } - else - { - qasymm8_signed_logistic_populate_table(_lut, qi_in, qi_out); - } - } + _lut = std::move(lut); } #endif // __aarch64__ - - static inline bool is_lut_supported(ActivationFunction act_func, DataType data_type) - { -#ifdef __aarch64__ - switch(act_func) - { - case ActivationFunction::HARD_SWISH: - return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED; - case ActivationFunction::LEAKY_RELU: - return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED; - case ActivationFunction::LOGISTIC: - return data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED; - default: - return false; - } -#else // __aarch64__ - ARM_COMPUTE_UNUSED(act_func); - ARM_COMPUTE_UNUSED(data_type); - return false; -#endif // __aarch64__ - } - private: ActivationFunction _act = { ActivationLayerInfo::ActivationFunction::IDENTITY }; float _a = {}; @@ -1789,54 +1734,6 @@ private: #ifdef __aarch64__ LookupTable256 _lut = {}; - - static inline void qasymm8_hard_swish_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_hard_swish(i, qi_in, qi_out); - } - } - - static inline void qasymm8_signed_hard_swish_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_signed_hard_swish(i, qi_in, qi_out); - } - } - - static inline void qasymm8_leaky_relu_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out, float alpha) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_leaky_relu(i, qi_in, qi_out, alpha); - } - } - - static inline void qasymm8_signed_leaky_relu_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out, float alpha) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_signed_leaky_relu(i, qi_in, qi_out, alpha); - } - } - - static inline void qasymm8_logistic_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_logistic(i, qi_in, qi_out); - } - } - - static inline void qasymm8_signed_logistic_populate_table(LookupTable256 &lut, const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out) - { - for(size_t i = 0; i < lut.size(); ++i) - { - lut[i] = qasymm8_signed_logistic(static_cast(i), qi_in, qi_out); - } - } #endif // __aarch64__ }; diff --git a/src/cpu/kernels/CpuActivationKernel.cpp b/src/cpu/kernels/CpuActivationKernel.cpp index 20a8489cdd..f4bd4e6cad 100644 --- a/src/cpu/kernels/CpuActivationKernel.cpp +++ b/src/cpu/kernels/CpuActivationKernel.cpp @@ -48,7 +48,7 @@ static const std::vector available_kernel #ifdef ARM_COMPUTE_ENABLE_SVE { "sve2_q8_activation_lut", - [](const ActivationDataTypeISASelectorData & data) { return ActivationLayerInfo::is_lut_supported(data.f, data.dt) && data.cpumodel == CPUModel::A510 && data.isa.sve2; }, + [](const ActivationDataTypeISASelectorData & data) { return (data.dt == DataType::QASYMM8 || data.dt == DataType::QASYMM8_SIGNED) && data.cpumodel == CPUModel::A510 && data.isa.sve2; }, REGISTER_QASYMM8_SVE2(arm_compute::cpu::sve2_q8_activation_lut) }, #endif // ARM_COMPUTE_ENABLE_SVE @@ -56,7 +56,7 @@ static const std::vector available_kernel { // Neon LUT implementantion takes precedence "neon_q8_activation_lut", - [](const ActivationDataTypeISASelectorData & data) { return ActivationLayerInfo::is_lut_supported(data.f, data.dt); }, + [](const ActivationDataTypeISASelectorData & data) { return data.dt == DataType::QASYMM8 || data.dt == DataType::QASYMM8_SIGNED; }, REGISTER_Q8_NEON(arm_compute::cpu::neon_q8_activation_lut) }, #endif // __aarch64__ @@ -184,6 +184,72 @@ std::pair validate_and_configure_window(const ITensorInfo *src, return std::make_pair(Status{}, win); } +#ifdef __aarch64__ +void init_lut(ActivationLayerInfo::ActivationFunction act_func, DataType data_type, + const UniformQuantizationInfo &qi_in, const UniformQuantizationInfo &qi_out, + ActivationLayerInfo::LookupTable256 &lut, float a, float b) +{ + for(size_t i = 0; i < lut.size(); ++i) + { + float tmp_f = (data_type == DataType::QASYMM8) ? dequantize_qasymm8(i, qi_in) : dequantize_qasymm8_signed(i, qi_in); + switch(act_func) + { + case ActivationLayerInfo::ActivationFunction::HARD_SWISH: + tmp_f = tmp_f * ((std::min(std::max((tmp_f + 3), 0.0f), 6.0f)) * 0.166666667f); + break; + case ActivationLayerInfo::ActivationFunction::LEAKY_RELU: + tmp_f = tmp_f > 0 ? tmp_f : tmp_f * a; + break; + case ActivationLayerInfo::ActivationFunction::LOGISTIC: + tmp_f = 1.f / (1.f + std::exp(-tmp_f)); + break; + case ActivationLayerInfo::ActivationFunction::ABS: + tmp_f = std::abs(tmp_f); + break; + case ActivationLayerInfo::ActivationFunction::LINEAR: + tmp_f = a * tmp_f + b; + break; + case ActivationLayerInfo::ActivationFunction::RELU: + tmp_f = std::max<>(0.f, tmp_f); + break; + case ActivationLayerInfo::ActivationFunction::BOUNDED_RELU: + tmp_f = std::min<>(a, std::max(0.f, tmp_f)); + break; + case ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU: + tmp_f = std::min<>(a, std::max<>(b, tmp_f)); + break; + case ActivationLayerInfo::ActivationFunction::SOFT_RELU: + tmp_f = (tmp_f > 12.f) ? tmp_f : std::log(1.f + std::exp(tmp_f)); + break; + case ActivationLayerInfo::ActivationFunction::ELU: + tmp_f = (tmp_f >= 0) ? tmp_f : a * (std::exp(tmp_f) - 1); + break; + case ActivationLayerInfo::ActivationFunction::SQRT: + tmp_f = std::sqrt(tmp_f); + break; + case ActivationLayerInfo::ActivationFunction::SQUARE: + tmp_f = tmp_f * tmp_f; + break; + case ActivationLayerInfo::ActivationFunction::TANH: + tmp_f = a * std::tanh(b * tmp_f); + break; + case ActivationLayerInfo::ActivationFunction::IDENTITY: + break; + case ActivationLayerInfo::ActivationFunction::SWISH: + tmp_f = tmp_f / (1.f + std::exp(-a * tmp_f)); + break; + case ActivationLayerInfo::ActivationFunction::GELU: + tmp_f = tmp_f * (0.5f * (1.0f + erff(tmp_f / 1.41421356237f))); + break; + default: + ARM_COMPUTE_ERROR("Not supported"); + tmp_f = 0; + break; + } + lut[i] = (data_type == DataType::QASYMM8) ? quantize_qasymm8(tmp_f, qi_out) : quantize_qasymm8_signed(tmp_f, qi_out); + } +} +#endif // __aarch64__ } // namespace void CpuActivationKernel::configure(const ITensorInfo *src, ITensorInfo *dst, ActivationLayerInfo activation_info) @@ -205,9 +271,12 @@ void CpuActivationKernel::configure(const ITensorInfo *src, ITensorInfo *dst, Ac _name = std::string("CpuActivationKernel").append("/").append(uk->name); #ifdef __aarch64__ - if(ActivationLayerInfo::is_lut_supported(activation_info.activation(), src->data_type())) + if(src->data_type() == DataType::QASYMM8 || src->data_type() == DataType::QASYMM8_SIGNED) { - activation_info.init_lut(src->data_type(), src->quantization_info().uniform(), (dst) ? dst->quantization_info().uniform() : src->quantization_info().uniform()); + ActivationLayerInfo::LookupTable256 tmp_lut; + init_lut(activation_info.activation(), src->data_type(), src->quantization_info().uniform(), (dst) ? dst->quantization_info().uniform() : src->quantization_info().uniform(), + tmp_lut, activation_info.a(), activation_info.b()); + activation_info.setLookupTable256(tmp_lut); } #endif // __aarch64__ _act_info = activation_info; diff --git a/src/cpu/kernels/activation/generic/neon/lut.cpp b/src/cpu/kernels/activation/generic/neon/lut.cpp index 90690ffcaa..b44347550e 100644 --- a/src/cpu/kernels/activation/generic/neon/lut.cpp +++ b/src/cpu/kernels/activation/generic/neon/lut.cpp @@ -32,7 +32,7 @@ namespace cpu #ifdef __aarch64__ void neon_q8_activation_lut(const ITensor *src, ITensor *dst, const ActivationLayerInfo &act_info, const Window &window) { - ARM_COMPUTE_ERROR_ON(!ActivationLayerInfo::is_lut_supported(act_info.activation(), src->info()->data_type())); + ARM_COMPUTE_ERROR_ON(src->info()->data_type() != DataType::QASYMM8 && src->info()->data_type() != DataType::QASYMM8_SIGNED); const auto window_end_x = window.x().end(); Window win_collapsed = window.collapse_if_possible(window, Window::DimZ); win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1)); diff --git a/src/cpu/kernels/activation/generic/sve2/lut.cpp b/src/cpu/kernels/activation/generic/sve2/lut.cpp index 2e5975744b..9dbeb305ff 100644 --- a/src/cpu/kernels/activation/generic/sve2/lut.cpp +++ b/src/cpu/kernels/activation/generic/sve2/lut.cpp @@ -32,7 +32,7 @@ namespace cpu #ifdef __aarch64__ void sve2_q8_activation_lut(const ITensor *src, ITensor *dst, const ActivationLayerInfo &act_info, const Window &window) { - ARM_COMPUTE_ERROR_ON(!ActivationLayerInfo::is_lut_supported(act_info.activation(), src->info()->data_type())); + ARM_COMPUTE_ERROR_ON(src->info()->data_type() != DataType::QASYMM8 && src->info()->data_type() != DataType::QASYMM8_SIGNED); const auto window_end_x = window.x().end(); Window win_collapsed = window.collapse_if_possible(window, Window::DimZ); win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1)); diff --git a/tests/validation/NEON/ActivationLayer.cpp b/tests/validation/NEON/ActivationLayer.cpp index d64945ab31..5de35fe942 100644 --- a/tests/validation/NEON/ActivationLayer.cpp +++ b/tests/validation/NEON/ActivationLayer.cpp @@ -316,10 +316,16 @@ DATA_TEST_CASE(KernelSelection, framework::DatasetMode::ALL, concat(concat( const auto *selected_impl = CpuActivationKernel::get_implementation(ActivationDataTypeISASelectorData{data_type, CPUModel::GENERIC, cpu_isa,ActivationLayerInfo::ActivationFunction::BOUNDED_RELU}, cpu::KernelSelectionType::Preferred); ARM_COMPUTE_ERROR_ON_NULLPTR(selected_impl); - std::string expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + "_activation"; + if( data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED) + { +#ifdef __aarch64__ + expected = "neon_q8_activation_lut"; +#else // __aarch64__ + expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + "_activation"; +#endif // __aarch64__ + } std::string actual = selected_impl->name; - ARM_COMPUTE_EXPECT_EQUAL(expected, actual, framework::LogLevel::ERRORS); } // clang-format on -- cgit v1.2.1