From d63dfa2fc61a33b4e675ec6bc7458d8700174134 Mon Sep 17 00:00:00 2001 From: Michele Di Giorgio Date: Wed, 12 Sep 2018 10:18:54 +0100 Subject: COMPMID-1568: Add support for QASYMM8 to CLNormalizePlanarYUV Change-Id: Id7ea6e7f57179478e5ba0e9231274e98fa089590 Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/148028 Tested-by: bsgcomp Reviewed-by: Georgios Pinitas --- .../CL/kernels/CLNormalizePlanarYUVLayerKernel.h | 4 +- .../CL/functions/CLNormalizePlanarYUVLayer.h | 6 +- src/core/CL/CLKernelLibrary.cpp | 6 + .../CL/cl_kernels/normalize_planar_yuv_layer.cl | 12 +- .../normalize_planar_yuv_layer_quantized.cl | 158 +++++++++++++++++++++ .../CL/kernels/CLNormalizePlanarYUVLayerKernel.cpp | 18 ++- tests/validation/CL/NormalizePlanarYUVLayer.cpp | 17 +++ .../fixtures/NormalizePlanarYUVLayerFixture.h | 54 +++++-- .../reference/NormalizePlanarYUVLayer.cpp | 11 ++ 9 files changed, 258 insertions(+), 28 deletions(-) create mode 100644 src/core/CL/cl_kernels/normalize_planar_yuv_layer_quantized.cl diff --git a/arm_compute/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.h b/arm_compute/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.h index 5418d31a0c..fd5042128f 100644 --- a/arm_compute/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.h +++ b/arm_compute/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.h @@ -50,7 +50,7 @@ public: /** Set the input and output tensors. * * @param[in] input Source tensor. 3 lower dimensions represent a single input with dimensions [width, height, channels]. - * Data types supported: F16/F32. + * Data types supported: QASYMM8/F16/F32. * @param[out] output Destination tensor. Data type supported: same as @p input * @param[in] mean Mean values tensor. 1 dimension with size equal to the number of input channels. Data types supported: same as @p input * @param[in] std Standard deviation values tensor. 1 dimension with size equal to the number of input channels. @@ -60,7 +60,7 @@ public: /** Static function to check if given info will lead to a valid configuration of @ref CLNormalizePlanarYUVLayerKernel * * @param[in] input Source tensor info. 3 lower dimensions represent a single input with dimensions [width, height, channels]. - * Data types supported: F16/F32. + * Data types supported: QASYMM8/F16/F32. * @param[out] output Destination tensor info. Data type supported: same as @p input * @param[in] mean Mean values tensor info. 1 dimension with size equal to the number of input channels. Data types supported: same as @p input * @param[in] std Standard deviation values tensor info. 1 dimension with size equal to the number of input channels. diff --git a/arm_compute/runtime/CL/functions/CLNormalizePlanarYUVLayer.h b/arm_compute/runtime/CL/functions/CLNormalizePlanarYUVLayer.h index 85f7d93ddf..6d28803150 100644 --- a/arm_compute/runtime/CL/functions/CLNormalizePlanarYUVLayer.h +++ b/arm_compute/runtime/CL/functions/CLNormalizePlanarYUVLayer.h @@ -45,7 +45,7 @@ public: /** Set the input and output tensors. * * @param[in] input Source tensor. 3 lower dimensions represent a single input with dimensions [width, height, channels]. - * Data types supported: F16/F32. + * Data types supported: QASYMM8/F16/F32. * @param[out] output Destinationfeature tensor. Data type supported: same as @p input * @param[in] mean Mean values tensor. 1 dimension with size equal to the number of input channels. Data types supported: Same as @p input * @param[in] std Standard deviation values tensor. 1 dimension with size equal to the number of input channels. @@ -54,8 +54,8 @@ public: void configure(const ICLTensor *input, ICLTensor *output, const ICLTensor *mean, const ICLTensor *std); /** Static function to check if given info will lead to a valid configuration of @ref CLNormalizePlanarYUVLayer * - * @param[in] input Source tensor info. 3 lower dimensions represent a single input with dimensions [width, height, FM]. - * Data types supported: F16/F32. + * @param[in] input Source tensor info. 3 lower dimensions represent a single input with dimensions [width, height, channels]. + * Data types supported: QASYMM8/F16/F32. * @param[out] output Destination tensor info. Data type supported: same as @p input * @param[in] mean Mean values tensor info. 1 dimension with size equal to the number of input channels. Data types supported: Same as @p input * @param[in] std Standard deviation values tensor info. 1 dimension with size equal to the number of input channels. diff --git a/src/core/CL/CLKernelLibrary.cpp b/src/core/CL/CLKernelLibrary.cpp index 8a309ec757..1bc1036bed 100644 --- a/src/core/CL/CLKernelLibrary.cpp +++ b/src/core/CL/CLKernelLibrary.cpp @@ -316,6 +316,8 @@ const std::map CLKernelLibrary::_kernel_program_map = { "normalization_layer_in_map", "normalization_layer.cl" }, { "normalize_planar_yuv_layer_nchw", "normalize_planar_yuv_layer.cl" }, { "normalize_planar_yuv_layer_nhwc", "normalize_planar_yuv_layer.cl" }, + { "normalize_planar_yuv_layer_q8_nchw", "normalize_planar_yuv_layer_quantized.cl" }, + { "normalize_planar_yuv_layer_q8_nhwc", "normalize_planar_yuv_layer_quantized.cl" }, { "NV12_to_IYUV_bt709", "color_convert.cl" }, { "NV12_to_RGB888_bt709", "color_convert.cl" }, { "NV12_to_RGBA8888_bt709", "color_convert.cl" }, @@ -696,6 +698,10 @@ const std::map CLKernelLibrary::_program_source_map = { "normalize_planar_yuv_layer.cl", #include "./cl_kernels/normalize_planar_yuv_layer.clembed" + }, + { + "normalize_planar_yuv_layer_quantized.cl", +#include "./cl_kernels/normalize_planar_yuv_layer_quantized.clembed" }, { "batchnormalization_layer.cl", diff --git a/src/core/CL/cl_kernels/normalize_planar_yuv_layer.cl b/src/core/CL/cl_kernels/normalize_planar_yuv_layer.cl index dc6652449e..a105968a7b 100644 --- a/src/core/CL/cl_kernels/normalize_planar_yuv_layer.cl +++ b/src/core/CL/cl_kernels/normalize_planar_yuv_layer.cl @@ -27,7 +27,7 @@ #define TYPE VEC_DATA_TYPE(DATA_TYPE, VEC_SIZE) -/** Apply normalize_planar_yuv layer on tensors with NCHW format. +/** Apply normalize_planar_yuv layer on tensors with NCHW data layout. * * @note Data type should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=float * @note Vector size should be given as a preprocessor argument using -DVEC_SIZE e.g. -DVEC_SIZE=8 @@ -70,8 +70,8 @@ __kernel void normalize_planar_yuv_layer_nchw(TENSOR3D_DECLARATION(src), const uint current_slice = get_global_id(2) % NUM_CHANNELS; - const DATA_TYPE curr_mean = *((__global DATA_TYPE *)(mean.ptr + current_slice * mean.stride_x)); - const DATA_TYPE curr_std = *((__global DATA_TYPE *)(std.ptr + current_slice * std.stride_x)); + const DATA_TYPE curr_mean = *((__global DATA_TYPE *)(mean.ptr + current_slice * sizeof(DATA_TYPE))); + const DATA_TYPE curr_std = *((__global DATA_TYPE *)(std.ptr + current_slice * sizeof(DATA_TYPE))); TYPE data = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)src.ptr); TYPE res = (data - curr_mean) / curr_std; @@ -80,7 +80,7 @@ __kernel void normalize_planar_yuv_layer_nchw(TENSOR3D_DECLARATION(src), (res, 0, (__global DATA_TYPE *)dst.ptr); } -/** Apply normalize_planar_yuv layer on tensors with NHWC format. +/** Apply normalize_planar_yuv layer on tensors with NHWC data layout. * * @note Data type should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=float * @note Vector size should be given as a preprocessor argument using -DVEC_SIZE e.g. -DVEC_SIZE=8 @@ -122,8 +122,8 @@ __kernel void normalize_planar_yuv_layer_nhwc(TENSOR3D_DECLARATION(src), const uint current_slice = get_global_id(0); - const TYPE curr_mean = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(mean.ptr + current_slice * VEC_SIZE * mean.stride_x)); - const TYPE curr_std = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(std.ptr + current_slice * VEC_SIZE * std.stride_x)); + const TYPE curr_mean = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(mean.ptr + current_slice * VEC_SIZE * sizeof(DATA_TYPE))); + const TYPE curr_std = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(std.ptr + current_slice * VEC_SIZE * sizeof(DATA_TYPE))); TYPE data = VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)src.ptr); TYPE res = (data - curr_mean) / curr_std; diff --git a/src/core/CL/cl_kernels/normalize_planar_yuv_layer_quantized.cl b/src/core/CL/cl_kernels/normalize_planar_yuv_layer_quantized.cl new file mode 100644 index 0000000000..925975d2ba --- /dev/null +++ b/src/core/CL/cl_kernels/normalize_planar_yuv_layer_quantized.cl @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2018 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 "helpers.h" + +#if defined(DATA_TYPE) && defined(VEC_SIZE) && defined(OFFSET) && defined(SCALE) + +#define TYPE VEC_DATA_TYPE(DATA_TYPE, VEC_SIZE) +#define OFFSET_FLT ((float)OFFSET) +#define SCALE_FLT ((float)SCALE) + +#if defined(NUM_CHANNELS) + +/** Apply normalize_planar_yuv layer on tensors with NCHW data layout. + * + * @note Data type should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=float + * @note Vector size should be given as a preprocessor argument using -DVEC_SIZE e.g. -DVEC_SIZE=8 + * @note The depth of the input tensor should be given as a preprocessor argument using -DNUM_CHANNELS e.g. -DNUM_CHANNELS=8 + * @note The quantization offset should be given as a preprocessor argument using -DOFFSET e.g. -DOFFSET=8 + * @note The quantization scale should be given as a preprocessor argument using -DSCALE e.g. -DSCALE=8 + * + * @param[in] src_ptr Pointer to the first source tensor. Supported data types: QASYMM8 + * @param[in] src_stride_x Stride of the first source tensor in X dimension (in bytes) + * @param[in] src_step_x input_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] src_stride_y Stride of the first source tensor in Y dimension (in bytes) + * @param[in] src_step_y input_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] src_stride_z Stride of the first source tensor in Z dimension (in bytes) + * @param[in] src_step_z input_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] src_offset_first_element_in_bytes The offset of the first element in the first source tensor + * @param[out] dst_ptr Pointer to the destination tensor. Supported data types: same as @p src_ptr + * @param[in] dst_stride_x Stride of the destination tensor in X dimension (in bytes) + * @param[in] dst_step_x output_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] dst_stride_y Stride of the destination tensor in Y dimension (in bytes) + * @param[in] dst_step_y output_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] dst_stride_z Stride of the destination tensor in Z dimension (in bytes) + * @param[in] dst_step_z output_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] dst_offset_first_element_in_bytes The offset of the first element in the destination tensor + * @param[in] mean_ptr Pointer to the mean source tensor. Supported data types: same as @p src_ptr + * @param[in] mean_stride_x Stride of the mean source tensor in X dimension (in bytes) + * @param[in] mean_step_x mean_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] mean_offset_first_element_in_bytes The offset of the first element in the mean source tensor + * @param[in] std_ptr Pointer to the std tensor. Supported data types: same as @p src_ptr + * @param[in] std_stride_x Stride of the std tensor in X dimension (in bytes) + * @param[in] std_step_x std_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] std_offset_first_element_in_bytes The offset of the first element in the var source tensor + */ +__kernel void normalize_planar_yuv_layer_q8_nchw(TENSOR3D_DECLARATION(src), + TENSOR3D_DECLARATION(dst), + VECTOR_DECLARATION(mean), + VECTOR_DECLARATION(std)) +{ + Tensor3D src = CONVERT_TO_TENSOR3D_STRUCT(src); + Tensor3D dst = CONVERT_TO_TENSOR3D_STRUCT(dst); + Vector mean = CONVERT_TO_VECTOR_STRUCT(mean); + Vector std = CONVERT_TO_VECTOR_STRUCT(std); + + const uint current_slice = get_global_id(2) % NUM_CHANNELS; + + float16 curr_mean_flt = (float16)(*((__global DATA_TYPE *)(mean.ptr + current_slice * sizeof(DATA_TYPE)))); + curr_mean_flt = round(curr_mean_flt - OFFSET_FLT) * SCALE_FLT; + + float16 curr_std_flt = (float16)(*((__global DATA_TYPE *)(std.ptr + current_slice * sizeof(DATA_TYPE)))); + curr_std_flt = round(curr_std_flt - OFFSET_FLT) * SCALE_FLT; + + float16 data_flt = CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)src.ptr), float16); + data_flt = round(data_flt - OFFSET_FLT) * SCALE_FLT; + + // Perform normalization + float16 res_flt = (data_flt - curr_mean_flt) / curr_std_flt; + + const TYPE res_u8 = CONVERT_SAT(round(res_flt / SCALE_FLT) + OFFSET_FLT, TYPE); + VSTORE(VEC_SIZE) + (res_u8, 0, (__global DATA_TYPE *)dst.ptr); +} + +#endif // defined(NUM_CHANNELS) + +/** Apply normalize_planar_yuv layer on tensors with NHWC data layout. + * + * @note Data type should be given as a preprocessor argument using -DDATA_TYPE=type. e.g. -DDATA_TYPE=float + * @note Vector size should be given as a preprocessor argument using -DVEC_SIZE e.g. -DVEC_SIZE=8 + * @note The quantization offset should be given as a preprocessor argument using -DOFFSET e.g. -DOFFSET=8 + * @note The quantization scale should be given as a preprocessor argument using -DSCALE e.g. -DSCALE=8 + * + * @param[in] src_ptr Pointer to the first source tensor. Supported data types: QASYMM8 + * @param[in] src_stride_x Stride of the first source tensor in X dimension (in bytes) + * @param[in] src_step_x input_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] src_stride_y Stride of the first source tensor in Y dimension (in bytes) + * @param[in] src_step_y input_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] src_stride_z Stride of the first source tensor in Z dimension (in bytes) + * @param[in] src_step_z input_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] src_offset_first_element_in_bytes The offset of the first element in the first source tensor + * @param[out] dst_ptr Pointer to the destination tensor. Supported data types: same as @p src_ptr + * @param[in] dst_stride_x Stride of the destination tensor in X dimension (in bytes) + * @param[in] dst_step_x output_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] dst_stride_y Stride of the destination tensor in Y dimension (in bytes) + * @param[in] dst_step_y output_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] dst_stride_z Stride of the destination tensor in Z dimension (in bytes) + * @param[in] dst_step_z output_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] dst_offset_first_element_in_bytes The offset of the first element in the destination tensor + * @param[in] mean_ptr Pointer to the mean source tensor. Supported data types: same as @p src_ptr + * @param[in] mean_stride_x Stride of the mean source tensor in X dimension (in bytes) + * @param[in] mean_step_x mean_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] mean_offset_first_element_in_bytes The offset of the first element in the mean source tensor + * @param[in] std_ptr Pointer to the std tensor. Supported data types: same as @p src_ptr + * @param[in] std_stride_x Stride of the std tensor in X dimension (in bytes) + * @param[in] std_step_x std_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] std_offset_first_element_in_bytes The offset of the first element in the var source tensor + */ +__kernel void normalize_planar_yuv_layer_q8_nhwc(TENSOR3D_DECLARATION(src), + TENSOR3D_DECLARATION(dst), + VECTOR_DECLARATION(mean), + VECTOR_DECLARATION(std)) +{ + Tensor3D src = CONVERT_TO_TENSOR3D_STRUCT(src); + Tensor3D dst = CONVERT_TO_TENSOR3D_STRUCT(dst); + Vector mean = CONVERT_TO_VECTOR_STRUCT(mean); + Vector std = CONVERT_TO_VECTOR_STRUCT(std); + + const uint current_slice = get_global_id(0); + + float16 curr_mean_flt = CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(mean.ptr + current_slice * VEC_SIZE * sizeof(DATA_TYPE))), float16); + curr_mean_flt = round(curr_mean_flt - OFFSET_FLT) * SCALE_FLT; + + float16 curr_std_flt = CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)(std.ptr + current_slice * VEC_SIZE * sizeof(DATA_TYPE))), float16); + curr_std_flt = round(curr_std_flt - OFFSET_FLT) * SCALE_FLT; + + float16 data_flt = CONVERT(VLOAD(VEC_SIZE)(0, (__global DATA_TYPE *)src.ptr), float16); + data_flt = round(data_flt - OFFSET_FLT) * (SCALE_FLT); + + // Perform normalization + float16 res_flt = (data_flt - curr_mean_flt) / curr_std_flt; + + const TYPE res_u8 = CONVERT_SAT(round(res_flt / SCALE_FLT) + OFFSET_FLT, TYPE); + VSTORE(VEC_SIZE) + (res_u8, 0, (__global DATA_TYPE *)dst.ptr); +} +#endif // defined(DATA_TYPE) && defined(VEC_SIZE) && defined(OFFSET) && defined(SCALE) diff --git a/src/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.cpp b/src/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.cpp index 31451ef422..a44507b0c6 100644 --- a/src/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.cpp +++ b/src/core/CL/kernels/CLNormalizePlanarYUVLayerKernel.cpp @@ -42,7 +42,7 @@ namespace Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *mean, const ITensorInfo *std) { ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(input); - ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8, DataType::F16, DataType::F32); ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(output); ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, mean, std); @@ -111,15 +111,25 @@ void CLNormalizePlanarYUVLayerKernel::configure(const ICLTensor *input, ICLTenso const unsigned int num_elems_processed_per_iteration = 16 / input->info()->element_size(); const unsigned int channel_idx = get_data_layout_dimension_index(input->info()->data_layout(), DataLayoutDimension::CHANNEL); + const DataType dt = input->info()->data_type(); // Set build options CLBuildOptions build_opts; - build_opts.add_option(("-DDATA_TYPE=" + get_cl_type_from_data_type(input->info()->data_type()))); + build_opts.add_option(("-DDATA_TYPE=" + get_cl_type_from_data_type(dt))); build_opts.add_option(("-DVEC_SIZE=" + support::cpp11::to_string(num_elems_processed_per_iteration))); build_opts.add_option(("-DNUM_CHANNELS=" + support::cpp11::to_string(input->info()->dimension(channel_idx)))); + std::string kernel_name = "normalize_planar_yuv_layer_"; + if(is_data_type_quantized(dt)) + { + build_opts.add_option(("-DOFFSET=" + support::cpp11::to_string(input->info()->quantization_info().offset))); + build_opts.add_option(("-DSCALE=" + support::cpp11::to_string(input->info()->quantization_info().scale))); + kernel_name += "q8_"; + } + // Create kernel - _kernel = static_cast(CLKernelLibrary::get().create_kernel("normalize_planar_yuv_layer_" + lower_string(string_from_data_layout(input->info()->data_layout())), build_opts.options())); + kernel_name += lower_string(string_from_data_layout(input->info()->data_layout())); + _kernel = static_cast(CLKernelLibrary::get().create_kernel(kernel_name, build_opts.options())); // Configure kernel window auto win_config = validate_and_configure_window(input->info(), output->info(), mean->info(), std->info()); @@ -130,7 +140,7 @@ void CLNormalizePlanarYUVLayerKernel::configure(const ICLTensor *input, ICLTenso _config_id = "normalize_planar_yuv_layer_"; _config_id += lower_string(string_from_data_layout(input->info()->data_layout())); _config_id += "_"; - _config_id += lower_string(string_from_data_type(input->info()->data_type())); + _config_id += lower_string(string_from_data_type(dt)); _config_id += "_"; _config_id += support::cpp11::to_string(input->info()->dimension(0)); _config_id += "_"; diff --git a/tests/validation/CL/NormalizePlanarYUVLayer.cpp b/tests/validation/CL/NormalizePlanarYUVLayer.cpp index aa1a00e106..31e0625eed 100644 --- a/tests/validation/CL/NormalizePlanarYUVLayer.cpp +++ b/tests/validation/CL/NormalizePlanarYUVLayer.cpp @@ -45,6 +45,7 @@ namespace { constexpr RelativeTolerance tolerance_f16(0.001f); /**< Tolerance value for comparing reference's output against implementation's output for DataType::F16 */ constexpr RelativeTolerance tolerance_f32(0.001f); /**< Tolerance value for comparing reference's output against implementation's output for DataType::F32 */ +constexpr AbsoluteTolerance tolerance_qasymm8(1); /**< Tolerance value for comparing reference's output against implementation's output for quantized data types */ } // namespace TEST_SUITE(CL) @@ -135,6 +136,22 @@ FIXTURE_DATA_TEST_CASE(Random, CLNormalizePlanarYUVLayerFixture, framewor TEST_SUITE_END() TEST_SUITE_END() +template +using CLNormalizePlanarYUVLayerQuantizedFixture = NormalizePlanarYUVLayerValidationQuantizedFixture; + +TEST_SUITE(Quantized) +TEST_SUITE(QASYMM8) +FIXTURE_DATA_TEST_CASE(Random, CLNormalizePlanarYUVLayerQuantizedFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::RandomNormalizePlanarYUVLayerDataset(), + framework::dataset::make("DataType", DataType::QASYMM8)), + framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) +{ + // Validate output + validate(CLAccessor(_target), _reference, tolerance_qasymm8, 0); +} +TEST_SUITE_END() +TEST_SUITE_END() + TEST_SUITE_END() TEST_SUITE_END() } // namespace validation diff --git a/tests/validation/fixtures/NormalizePlanarYUVLayerFixture.h b/tests/validation/fixtures/NormalizePlanarYUVLayerFixture.h index cc73e530ef..9d8c8fcbce 100644 --- a/tests/validation/fixtures/NormalizePlanarYUVLayerFixture.h +++ b/tests/validation/fixtures/NormalizePlanarYUVLayerFixture.h @@ -41,15 +41,15 @@ namespace test namespace validation { template -class NormalizePlanarYUVLayerValidationFixture : public framework::Fixture +class NormalizePlanarYUVLayerValidationGenericFixture : public framework::Fixture { public: template - void setup(TensorShape shape0, TensorShape shape1, DataType dt, DataLayout data_layout) + void setup(TensorShape shape0, TensorShape shape1, DataType dt, DataLayout data_layout, QuantizationInfo quantization_info) { _data_type = dt; - _target = compute_target(shape0, shape1, dt, data_layout); - _reference = compute_reference(shape0, shape1, dt); + _target = compute_target(shape0, shape1, dt, data_layout, quantization_info); + _reference = compute_reference(shape0, shape1, dt, quantization_info); } protected: @@ -67,9 +67,15 @@ protected: library->fill(mean_tensor, distribution, 1); library->fill(std_tensor, distribution_std, 2); } + else if(is_data_type_quantized_asymmetric(src_tensor.data_type())) + { + library->fill_tensor_uniform(src_tensor, 0); + library->fill_tensor_uniform(mean_tensor, 1); + library->fill_tensor_uniform(std_tensor, 2); + } } - TensorType compute_target(TensorShape shape0, const TensorShape &shape1, DataType dt, DataLayout data_layout) + TensorType compute_target(TensorShape shape0, const TensorShape &shape1, DataType dt, DataLayout data_layout, QuantizationInfo quantization_info) { if(data_layout == DataLayout::NHWC) { @@ -77,10 +83,10 @@ protected: } // Create tensors - TensorType src = create_tensor(shape0, dt, 1, QuantizationInfo(), data_layout); - TensorType dst = create_tensor(shape0, dt, 1, QuantizationInfo(), data_layout); - TensorType mean = create_tensor(shape1, dt, 1); - TensorType std = create_tensor(shape1, dt, 1); + TensorType src = create_tensor(shape0, dt, 1, quantization_info, data_layout); + TensorType mean = create_tensor(shape1, dt, 1, quantization_info); + TensorType std = create_tensor(shape1, dt, 1, quantization_info); + TensorType dst; // Create and configure function FunctionType norm; @@ -111,12 +117,12 @@ protected: return dst; } - SimpleTensor compute_reference(const TensorShape &shape0, const TensorShape &shape1, DataType dt) + SimpleTensor compute_reference(const TensorShape &shape0, const TensorShape &shape1, DataType dt, QuantizationInfo quantization_info) { // Create reference - SimpleTensor ref_src{ shape0, dt, 1 }; - SimpleTensor ref_mean{ shape1, dt, 1 }; - SimpleTensor ref_std{ shape1, dt, 1 }; + SimpleTensor ref_src{ shape0, dt, 1, quantization_info }; + SimpleTensor ref_mean{ shape1, dt, 1, quantization_info }; + SimpleTensor ref_std{ shape1, dt, 1, quantization_info }; // Fill reference fill(ref_src, ref_mean, ref_std); @@ -128,6 +134,28 @@ protected: SimpleTensor _reference{}; DataType _data_type{}; }; + +template +class NormalizePlanarYUVLayerValidationFixture : public NormalizePlanarYUVLayerValidationGenericFixture +{ +public: + template + void setup(TensorShape shape0, TensorShape shape1, DataType dt, DataLayout data_layout) + { + NormalizePlanarYUVLayerValidationGenericFixture::setup(shape0, shape1, dt, data_layout, QuantizationInfo()); + } +}; + +template +class NormalizePlanarYUVLayerValidationQuantizedFixture : public NormalizePlanarYUVLayerValidationGenericFixture +{ +public: + template + void setup(TensorShape shape0, TensorShape shape1, DataType dt, DataLayout data_layout, QuantizationInfo quantization_info) + { + NormalizePlanarYUVLayerValidationGenericFixture::setup(shape0, shape1, dt, data_layout, quantization_info); + } +}; } // namespace validation } // namespace test } // namespace arm_compute diff --git a/tests/validation/reference/NormalizePlanarYUVLayer.cpp b/tests/validation/reference/NormalizePlanarYUVLayer.cpp index cdccaf49cd..563e2a7444 100644 --- a/tests/validation/reference/NormalizePlanarYUVLayer.cpp +++ b/tests/validation/reference/NormalizePlanarYUVLayer.cpp @@ -61,6 +61,17 @@ SimpleTensor normalize_planar_yuv_layer(const SimpleTensor &src, const Sim return result; } +template <> +SimpleTensor normalize_planar_yuv_layer(const SimpleTensor &src, const SimpleTensor &mean, const SimpleTensor &std) +{ + SimpleTensor src_tmp = convert_from_asymmetric(src); + SimpleTensor mean_tmp = convert_from_asymmetric(mean); + SimpleTensor std_tmp = convert_from_asymmetric(std); + SimpleTensor dst_tmp = normalize_planar_yuv_layer(src_tmp, mean_tmp, std_tmp); + SimpleTensor dst = convert_to_asymmetric(dst_tmp, src.quantization_info()); + return dst; +} + template SimpleTensor normalize_planar_yuv_layer(const SimpleTensor &src, const SimpleTensor &mean, const SimpleTensor &std); template SimpleTensor normalize_planar_yuv_layer(const SimpleTensor &src, const SimpleTensor &mean, const SimpleTensor &std); } // namespace reference -- cgit v1.2.1