diff options
17 files changed, 409 insertions, 550 deletions
diff --git a/arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h b/arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h index 25fd3378cb..3dfb19b306 100644 --- a/arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h +++ b/arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -30,11 +30,7 @@ namespace arm_compute { class ICLTensor; -/** Interface for the dequantization layer kernel. - * - * @note The implementation supports only 3D input tensors. - * - */ +/** Interface for the dequantization layer kernel. */ class CLDequantizationLayerKernel : public ICLKernel { public: @@ -52,22 +48,18 @@ public: ~CLDequantizationLayerKernel() = default; /** Set the input, output, min and max. * - * @param[in] input Source tensor. Data types supported: U8. - * @param[out] output Destination tensor. Data types supported: F32. - * @param[in] min_max Pointer to the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Source tensor. Data types supported: QASYMM8. + * @param[out] output Destination tensor. Data types supported: F16/F32. */ - void configure(const ICLTensor *input, ICLTensor *output, const ICLTensor *min_max); + void configure(const ICLTensor *input, ICLTensor *output); /** Static function to check if given info will lead to a valid configuration of @ref CLDequantizationLayerKernel * - * @param[in] input Input tensor info. Data types supported: U8. - * @param[in] output Output tensor info. Data types supported: F32. - * @param[in] min_max Info for the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Input tensor info. Data types supported: QASYMM8. + * @param[in] output Output tensor info. Data types supported: F16/F32. * * @return a status */ - static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max); + static Status validate(const ITensorInfo *input, const ITensorInfo *output); // Inherited methods overridden: void run(const Window &window, cl::CommandQueue &queue) override; @@ -75,7 +67,6 @@ public: private: const ICLTensor *_input; ICLTensor *_output; - const ICLTensor *_min_max; }; } // namespace arm_compute #endif /*__ARM_COMPUTE_CLDEQUANTIZATIONLAYERKERNEL_H__ */ diff --git a/arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h b/arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h index f48e76f340..7d215f5f7b 100644 --- a/arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h +++ b/arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -30,11 +30,7 @@ namespace arm_compute { class ITensor; -/** Interface for the dequantization layer kernel. - * - * @note The implementation supports only 3D input tensors - * - */ +/** Interface for the dequantization layer kernel. */ class NEDequantizationLayerKernel : public INEKernel { public: @@ -54,24 +50,20 @@ public: NEDequantizationLayerKernel &operator=(NEDequantizationLayerKernel &&) = default; /** Default destructor */ ~NEDequantizationLayerKernel() = default; - /** Set input, output, min and max. + /** Set input, output tensors. * - * @param[in] input Source tensor with at least 3 dimensions. The dimensions over the third will be interpreted as batches. Data type supported: U8. - * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F32. - * @param[in] min_max Pointer to the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32 + * @param[in] input Source tensor. Data type supported: QASYMM8. + * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F16/F32. */ - void configure(const ITensor *input, ITensor *output, const ITensor *min_max); + void configure(const ITensor *input, ITensor *output); /** Static function to check if given info will lead to a valid configuration of @ref NEDequantizationLayerKernel * - * @param[in] input Input tensor info. Data types supported: U8. - * @param[in] output Output tensor info. Data types supported: F32. - * @param[in] min_max Info for the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Input tensor info. Data types supported: QASYMM8. + * @param[in] output Output tensor info. Data types supported: F16/F32. * * @return a status */ - static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max); + static Status validate(const ITensorInfo *input, const ITensorInfo *output); // Inherited methods overridden: void run(const Window &window, const ThreadInfo &info) override; @@ -79,7 +71,6 @@ public: private: const ITensor *_input; ITensor *_output; - const ITensor *_min_max; }; } // namespace arm_compute #endif /*__ARM_COMPUTE_NEDEQUANTIZATIONLAYERKERNEL_H__ */ diff --git a/arm_compute/runtime/CL/functions/CLDequantizationLayer.h b/arm_compute/runtime/CL/functions/CLDequantizationLayer.h index efd28fc819..cf7c5761e4 100644 --- a/arm_compute/runtime/CL/functions/CLDequantizationLayer.h +++ b/arm_compute/runtime/CL/functions/CLDequantizationLayer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -24,55 +24,33 @@ #ifndef __ARM_COMPUTE_CLDEQUANTIZATIONLAYER_H__ #define __ARM_COMPUTE_CLDEQUANTIZATIONLAYER_H__ -#include "arm_compute/runtime/IFunction.h" - -#include "arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h" -#include "arm_compute/runtime/Tensor.h" +#include "arm_compute/runtime/CL/ICLSimpleFunction.h" #include "arm_compute/core/Types.h" namespace arm_compute { +// Forward declarations class ICLTensor; -/** Basic function to simulate a dequantization layer. This function calls the following CL kernels: - * - * -# @ref CLDequantizationLayerKernel - * - */ -class CLDequantizationLayer : public IFunction +/** Basic function to run @ref CLDequantizationLayerKernel that dequantizes an input tensor */ +class CLDequantizationLayer : public ICLSimpleFunction { public: - /** Default constructor */ - CLDequantizationLayer(); - /** Prevent instances of this class from being copied (As this class contains pointers) */ - CLDequantizationLayer(const CLDequantizationLayer &) = delete; - /** Prevent instances of this class from being copied (As this class contains pointers) */ - CLDequantizationLayer &operator=(const CLDequantizationLayer &) = delete; /** Set the input and output tensors. * - * @param[in] input Source tensor with at least 3 dimensions. The dimensions over the third will be interpreted as batches. Data types supported: U8. - * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F32. - * @param[in] min_max Pointer to the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Source tensor with at least 3 dimensions. The dimensions over the third will be interpreted as batches. Data types supported: QASYMM8. + * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F16/F32. */ - void configure(const ICLTensor *input, ICLTensor *output, const ICLTensor *min_max); + void configure(const ICLTensor *input, ICLTensor *output); /** Static function to check if given info will lead to a valid configuration of @ref CLDequantizationLayer * - * @param[in] input Input tensor info. Data types supported: U8. - * @param[in] output Output tensor info. Data type supported: F32. - * @param[in] min_max Info for the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Input tensor info. Data types supported: QASYMM8. + * @param[in] output Output tensor info. Data type supported: F16/F32. * * @return a status */ - static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max); - - // Inherited methods overridden: - void run() override; - -private: - CLDequantizationLayerKernel _dequantize_kernel; + static Status validate(const ITensorInfo *input, const ITensorInfo *output); }; -} +} // namespace arm_compute #endif /* __ARM_COMPUTE_CLDEQUANTIZATIONLAYER_H__ */ diff --git a/arm_compute/runtime/NEON/functions/NEDequantizationLayer.h b/arm_compute/runtime/NEON/functions/NEDequantizationLayer.h index 90c454ef3e..b7c5bac844 100644 --- a/arm_compute/runtime/NEON/functions/NEDequantizationLayer.h +++ b/arm_compute/runtime/NEON/functions/NEDequantizationLayer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -24,52 +24,33 @@ #ifndef __ARM_COMPUTE_NEDEQUANTIZATIONLAYER_H__ #define __ARM_COMPUTE_NEDEQUANTIZATIONLAYER_H__ -#include "arm_compute/runtime/IFunction.h" - -#include "arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h" +#include "arm_compute/runtime/NEON/INESimpleFunctionNoBorder.h" #include "arm_compute/core/Types.h" namespace arm_compute { +// Forward declarations class ITensor; -/** Basic function to simulate a dequantization layer. This function calls the following NEON kernels: - * - * @note The implementation supports only 3D input tensors - * - * -# @ref NEDequantizationLayerKernel - * - */ -class NEDequantizationLayer : public IFunction +/** Basic function to run @ref NEDequantizationLayerKernel that dequantizes an input tensor */ +class NEDequantizationLayer : public INESimpleFunctionNoBorder { public: - /** Default constructor */ - NEDequantizationLayer(); /** Configure the kernel. * - * @param[in] input Source tensor with at least 3 dimensions. The dimensions over the third will be interpreted as batches. Data types supported: U8. - * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F32. - * @param[in] min_max Pointer to the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32 + * @param[in] input Source tensor. Data types supported: QASYMM8. + * @param[out] output Destination tensor with the same dimensions of input. Data type supported: F16/F32. */ - void configure(const ITensor *input, ITensor *output, const ITensor *min_max); + void configure(const ITensor *input, ITensor *output); /** Static function to check if given info will lead to a valid configuration of @ref NEDequantizationLayer * - * @param[in] input Input tensor info. Data types supported: U8. - * @param[in] output Output tensor info. Data type supported: F32. - * @param[in] min_max Info for the tensor with shape [2, batches] which stores the minimum and maximum value for each 3D input tensor. - * The dimensions over the second must match the batched dimensions of the input tensor. Data type supported: F32. + * @param[in] input Input tensor info. Data types supported: QASYMM8. + * @param[in] output Output tensor info. Data type supported: F16/F32. * * @return a status */ - static Status validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max); - - // Inherited methods overridden: - void run() override; - -private: - NEDequantizationLayerKernel _dequantize_kernel; + static Status validate(const ITensorInfo *input, const ITensorInfo *output); }; -} +} // namespace arm_compute #endif /* __ARM_COMPUTE_NEDEQUANTIZATIONLAYER_H__ */ diff --git a/src/core/CL/cl_kernels/dequantization_layer.cl b/src/core/CL/cl_kernels/dequantization_layer.cl index 4908bb0b31..7307700473 100644 --- a/src/core/CL/cl_kernels/dequantization_layer.cl +++ b/src/core/CL/cl_kernels/dequantization_layer.cl @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -23,51 +23,68 @@ */ #include "helpers.h" +#if defined(VEC_SIZE) && defined(DATA_TYPE) && defined(SCALE) && defined(OFFSET) + /** This performs the dequantization of 8-bit unsigned integers to floating point. * - * @param[in] input_ptr Pointer to the source image. Supported data types: F16/F32 - * @param[in] input_stride_x Stride of the source image in X dimension (in bytes) - * @param[in] input_step_x input_stride_x * number of elements along X processed per workitem(in bytes) - * @param[in] input_stride_y Stride of the source image in Y dimension (in bytes) - * @param[in] input_step_y input_stride_y * number of elements along Y processed per workitem(in bytes) - * @param[in] input_stride_z Stride of the source tensor in Z dimension (in bytes) - * @param[in] input_step_z input_stride_z * number of elements along Z processed per workitem(in bytes) - * @param[in] input_offset_first_element_in_bytes The offset of the first element in the source image - * @param[out] output_ptr Pointer to the destination image. Supported data types: same as @p input_ptr - * @param[in] output_stride_x Stride of the destination image in X dimension (in bytes) - * @param[in] output_step_x output_stride_x * number of elements along X processed per workitem(in bytes) - * @param[in] output_stride_y Stride of the destination image in Y dimension (in bytes) - * @param[in] output_step_y output_stride_y * number of elements along Y processed per workitem(in bytes) - * @param[in] output_stride_z Stride of the source tensor in Z dimension (in bytes) - * @param[in] output_step_z output_stride_z * number of elements along Z processed per workitem(in bytes) - * @param[in] output_offset_first_element_in_bytes The offset of the first element in the destination image - * @param[in] min_max_ptr Pointer to the min/max vector. Minimum value in position 0, maximum value in position 1. Suppported data types: F32. - * @param[in] min_max_stride_x Stride of the min/max vector in X dimension (in bytes) - * @param[in] min_max_step_x min_max_stride_x * number of elements along X processed per workitem(in bytes) - * @param[in] min_max_offset_first_element_in_bytes The offset of the first element in the min/max vector + * @note Datatype 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=size. e.g. -DVEC_SIZE=16 + * @note Quantization scale of input tensor is passed in with -DSCALE=scale. + * @note Quantization offset of input tensor is passed in with -DOFFSET=offset. + * + * @param[in] input_ptr Pointer to the source tensor. Supported data types: QASYMM8 + * @param[in] input_stride_x Stride of the source tensor in X dimension (in bytes) + * @param[in] input_step_x input_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] input_stride_y Stride of the source tensor in Y dimension (in bytes) + * @param[in] input_step_y input_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] input_stride_z Stride of the source tensor in Z dimension (in bytes) + * @param[in] input_step_z input_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] input_offset_first_element_in_bytes The offset of the first element in the source tensor + * @param[out] output_ptr Pointer to the destination tensor. Supported data types: F16/F32 + * @param[in] output_stride_x Stride of the destination tensor in X dimension (in bytes) + * @param[in] output_step_x output_stride_x * number of elements along X processed per workitem(in bytes) + * @param[in] output_stride_y Stride of the destination tensor in Y dimension (in bytes) + * @param[in] output_step_y output_stride_y * number of elements along Y processed per workitem(in bytes) + * @param[in] output_stride_z Stride of the source tensor in Z dimension (in bytes) + * @param[in] output_step_z output_stride_z * number of elements along Z processed per workitem(in bytes) + * @param[in] output_offset_first_element_in_bytes The offset of the first element in the destination tensor */ __kernel void dequantization_layer( TENSOR3D_DECLARATION(input), - TENSOR3D_DECLARATION(output), - VECTOR_DECLARATION(min_max)) + TENSOR3D_DECLARATION(output)) { // Get pixels pointer - Tensor3D input = CONVERT_TO_TENSOR3D_STRUCT(input); - Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output); - Vector min_max = CONVERT_TO_VECTOR_STRUCT(min_max); - - // min_max_value.s0 = min, min_max_value.s1 = max - const float2 min_max_value = vload2(0, (__global float *)min_max.ptr); + Tensor3D input = CONVERT_TO_TENSOR3D_STRUCT(input); + Tensor3D output = CONVERT_TO_TENSOR3D_STRUCT(output); - const float4 vmin = (float4)min_max_value.s0; - const float4 scale = (float4)((min_max_value.s1 - min_max_value.s0) / 255.0f); +#if defined(VEC_SIZE) && defined(LAST_ACCESSED_X) + // Check if access on width gets out of bounds + // If it does shift access vector to access elements within bounds + const int xi = (int)(get_global_id(0) * VEC_SIZE); + input.ptr -= max(xi - (int)LAST_ACCESSED_X, 0) * input_stride_x; + output.ptr -= max(xi - (int)LAST_ACCESSED_X, 0) * output_stride_x; // Load data - const uchar4 data = vload4(0, (__global uchar *)input.ptr); + VEC_DATA_TYPE(int, VEC_SIZE) + val = CONVERT(VLOAD(VEC_SIZE)(0, (__global uchar *)input.ptr), VEC_DATA_TYPE(int, VEC_SIZE)); + + // Create scale and offset vectors + const VEC_DATA_TYPE(float, VEC_SIZE) + vscale = SCALE; + + const VEC_DATA_TYPE(int, VEC_SIZE) + voffset = OFFSET; // Dequantize - const float4 res = convert_float4(data) * scale + vmin; + VEC_DATA_TYPE(float, VEC_SIZE) + res = vscale * CONVERT((val - voffset), VEC_DATA_TYPE(float, VEC_SIZE)); // Store result - vstore4(res, 0, (__global float *)output.ptr); + VSTORE(VEC_SIZE) + (CONVERT(res, VEC_DATA_TYPE(DATA_TYPE, VEC_SIZE)), 0, (__global DATA_TYPE *)output.ptr); +#else // !defined(VEC_SIZE) || !defined(LAST_ACCESSED_X) + *((__global DATA_TYPE *)(output.ptr)) = (DATA_TYPE)((float)((int)(*((__global uchar *)(input.ptr))) - (int)(OFFSET)) * (float)(SCALE)); +#endif // defined(VEC_SIZE) && defined(LAST_ACCESSED_X) } + +#endif // defined(VEC_SIZE) && defined(DATA_TYPE) && defined(SCALE) && defined(OFFSET)
\ No newline at end of file diff --git a/src/core/CL/kernels/CLDequantizationLayerKernel.cpp b/src/core/CL/kernels/CLDequantizationLayerKernel.cpp index d4c1bec5f4..78cc5596dd 100644 --- a/src/core/CL/kernels/CLDequantizationLayerKernel.cpp +++ b/src/core/CL/kernels/CLDequantizationLayerKernel.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -26,6 +26,7 @@ #include "arm_compute/core/AccessWindowStatic.h" #include "arm_compute/core/CL/CLHelpers.h" #include "arm_compute/core/CL/CLKernelLibrary.h" +#include "arm_compute/core/CL/CLValidate.h" #include "arm_compute/core/CL/ICLTensor.h" #include "arm_compute/core/TensorInfo.h" #include "arm_compute/core/Utils.h" @@ -36,74 +37,78 @@ using namespace arm_compute; namespace { -Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output) { - ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8); - ARM_COMPUTE_RETURN_ERROR_ON(input->num_dimensions() < 3); + ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8); if(output->tensor_shape().total_size() > 0) { - ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F32); + ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(output); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F16, DataType::F32); ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input, output); } return Status{}; } -std::tuple<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output, ITensorInfo *min_max) +std::tuple<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output) { + // Configure kernel window + Window win = calculate_max_window(*input, Steps()); + // Output tensor auto initialization if not yet initialized auto_init_if_empty(*output, input->tensor_shape(), 1, DataType::F32); - constexpr unsigned int num_elems_processed_per_iteration = 4; - - // Configure window - Window win = calculate_max_window(*input, Steps(num_elems_processed_per_iteration)); - AccessWindowHorizontal input_access(input, 0, num_elems_processed_per_iteration); - AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration); - AccessWindowStatic min_max_access(min_max, 0, 0, 2, min_max->dimension(1)); - - // Update window and padding - bool window_changed = update_window_and_padding(win, input_access, output_access, min_max_access); + // CLDequantizationLayerKernel doesn't need padding so update_window_and_padding() can be skipped + Coordinates coord; + coord.set_num_dimensions(output->num_dimensions()); + output->set_valid_region(ValidRegion(coord, output->tensor_shape())); - output_access.set_valid_region(win, input->valid_region()); - - Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{}; - return std::make_tuple(err, win); + return std::make_tuple(Status{}, win); } } // namespace CLDequantizationLayerKernel::CLDequantizationLayerKernel() - : _input(nullptr), _output(nullptr), _min_max(nullptr) + : _input(nullptr), _output(nullptr) { } -void CLDequantizationLayerKernel::configure(const ICLTensor *input, ICLTensor *output, const ICLTensor *min_max) +void CLDequantizationLayerKernel::configure(const ICLTensor *input, ICLTensor *output) { - ARM_COMPUTE_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), min_max->info())); - - _input = input; - _output = output; - _min_max = min_max; + ARM_COMPUTE_ERROR_ON_NULLPTR(input, output); + ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info())); - // Create kernel - _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("dequantization_layer")); + _input = input; + _output = output; - // Configure kernel window - auto win_config = validate_and_configure_window(input->info(), output->info(), min_max->info()); + const int vec_size_x = 16 / output->info()->element_size(); + const int output_width_x = output->info()->tensor_shape().x(); + const bool multi_access_x = (output_width_x / vec_size_x > 0); - ARM_COMPUTE_ERROR_THROW_ON(std::get<0>(win_config)); + // Create and update the window (if needed) + Window win = calculate_max_window(*output->info()); + if(multi_access_x) + { + win.set(Window::DimX, + Window::Dimension(win.x().start(), ceil_to_multiple(win.x().end(), vec_size_x), vec_size_x)); + } + ICLKernel::configure_internal(win); - ICLKernel::configure_internal(std::get<1>(win_config)); + // Create kernel + CLBuildOptions build_opts; + build_opts.add_option("-DSCALE=" + float_to_string_with_full_precision(input->info()->quantization_info().scale)); + build_opts.add_option("-DOFFSET=" + support::cpp11::to_string(input->info()->quantization_info().offset)); + build_opts.add_option("-DVEC_SIZE=" + support::cpp11::to_string(vec_size_x)); + build_opts.add_option("-DDATA_TYPE=" + get_cl_type_from_data_type(output->info()->data_type())); + build_opts.add_option_if(multi_access_x, "-DLAST_ACCESSED_X=" + support::cpp11::to_string(std::max<int>(output_width_x - vec_size_x, 0))); + _kernel = static_cast<cl::Kernel>(CLKernelLibrary::get().create_kernel("dequantization_layer", build_opts.options())); } -Status CLDequantizationLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +Status CLDequantizationLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output) { - ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, min_max)); - ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get(), min_max->clone().get()))); - + ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output)); + ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get()))); return Status{}; } @@ -115,20 +120,12 @@ void CLDequantizationLayerKernel::run(const Window &window, cl::CommandQueue &qu Window window_collapsed = window.collapse_if_possible(ICLKernel::window(), 3); Window slice = window_collapsed.first_slice_window_3D(); - Window min_max_window = window; - min_max_window.set(Window::DimX, Window::Dimension(0, 0, 0)); - min_max_window.set(Window::DimY, Window::Dimension(0, _min_max->info()->dimension(1), 1)); - min_max_window.set(Window::DimZ, Window::Dimension(0, 0, 0)); - - Window min_max_slice = min_max_window.first_slice_window_1D(); - do { unsigned int idx = 0; add_3D_tensor_argument(idx, _input, slice); add_3D_tensor_argument(idx, _output, slice); - add_1D_tensor_argument(idx, _min_max, min_max_slice); enqueue(queue, *this, slice); } - while(window_collapsed.slide_window_slice_3D(slice) && min_max_window.slide_window_slice_1D(min_max_slice)); + while(window_collapsed.slide_window_slice_3D(slice)); } diff --git a/src/core/NEON/kernels/NEDequantizationLayerKernel.cpp b/src/core/NEON/kernels/NEDequantizationLayerKernel.cpp index 47c895c594..119aa4ad9a 100644 --- a/src/core/NEON/kernels/NEDequantizationLayerKernel.cpp +++ b/src/core/NEON/kernels/NEDequantizationLayerKernel.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -24,83 +24,143 @@ #include "arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h" #include "arm_compute/core/AccessWindowStatic.h" +#include "arm_compute/core/CPP/Validate.h" #include "arm_compute/core/Error.h" #include "arm_compute/core/Helpers.h" +#include "arm_compute/core/NEON/NEAsymm.h" +#include "arm_compute/core/NEON/wrapper/wrapper.h" #include "arm_compute/core/Utils.h" #include "arm_compute/core/Validate.h" #include "arm_compute/core/Window.h" #include <arm_neon.h> -using namespace arm_compute; - +namespace arm_compute +{ namespace { -Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output) { - ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::U8); - ARM_COMPUTE_RETURN_ERROR_ON(input->num_dimensions() < 3); + ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QASYMM8); if(output->tensor_shape().total_size() > 0) { - ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F32); + ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(output); + ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(output, 1, DataType::F16, DataType::F32); ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input, output); } return Status{}; } -std::tuple<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output, ITensorInfo *min_max) +std::tuple<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output) { + // Configure kernel window + Window win = calculate_max_window(*input, Steps()); + // Output tensor auto initialization if not yet initialized auto_init_if_empty(*output, input->tensor_shape(), 1, DataType::F32); - constexpr unsigned int num_elems_processed_per_iteration = 8; + // NEDequantizationLayerKernel doesn't need padding so update_window_and_padding() can be skipped + Coordinates coord; + coord.set_num_dimensions(output->num_dimensions()); + output->set_valid_region(ValidRegion(coord, output->tensor_shape())); + + return std::make_tuple(Status{}, win); +} + +template <typename T> +inline void store_result(T *ptr, const float32x4x4_t &v) +{ + ARM_COMPUTE_UNUSED(ptr, v); +} + +template <> +inline void store_result<float>(float *ptr, const float32x4x4_t &v) +{ + wrapper::vstore(ptr, v.val[0]); + wrapper::vstore(ptr + 4, v.val[1]); + wrapper::vstore(ptr + 8, v.val[2]); + wrapper::vstore(ptr + 12, v.val[3]); +} + +#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC +template <> +inline void store_result<float16_t>(float16_t *ptr, const float32x4x4_t &v) +{ + wrapper::vstore(ptr, vcombine_f16(vcvt_f16_f32(v.val[0]), vcvt_f16_f32(v.val[1]))); + wrapper::vstore(ptr + 8, vcombine_f16(vcvt_f16_f32(v.val[2]), vcvt_f16_f32(v.val[3]))); +} +#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ + +template <typename T> +void run_dequantization(const ITensor *input, ITensor *output, const Window &window) +{ + const QuantizationInfo &qinfo = input->info()->quantization_info(); + + const int window_step_x = 16; + const auto window_start_x = static_cast<int>(window.x().start()); + const auto window_end_x = static_cast<int>(window.x().end()); + + // Collapse window and reset first dimension to handle tail calculations manually + Window win_collapsed = window.collapse_if_possible(window, Window::DimZ); + win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1)); - // Configure window - Window win = calculate_max_window(*input, Steps(num_elems_processed_per_iteration)); - AccessWindowHorizontal input_access(input, 0, num_elems_processed_per_iteration); - AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration); - AccessWindowStatic min_max_access(min_max, 0, 0, 2, min_max->dimension(1)); + // Create iterators + Iterator in(input, win_collapsed); + Iterator out(output, win_collapsed); - // Update window and padding - bool window_changed = update_window_and_padding(win, input_access, output_access, min_max_access); + execute_window_loop(win_collapsed, [&](const Coordinates & id) + { + const auto in_ptr = reinterpret_cast<const uint8_t *>(in.ptr()); + const auto out_ptr = reinterpret_cast<T *>(out.ptr()); + + int x = window_start_x; + for(; x <= (window_end_x - window_step_x); x += window_step_x) + { + const auto vin = wrapper::vloadq(in_ptr + x); + const auto vdeq = vdequantize(vin, qinfo); - output_access.set_valid_region(win, input->valid_region()); + store_result<T>(reinterpret_cast<T *>(out_ptr + x), vdeq); + } - Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{}; - return std::make_tuple(err, win); + // Compute left-over elements + for(; x < window_end_x; ++x) + { + uint8_t val = *(in_ptr + x); + *(out_ptr + x) = static_cast<T>(qinfo.dequantize(val)); + } + }, + in, out); } } // namespace NEDequantizationLayerKernel::NEDequantizationLayerKernel() - : _input(nullptr), _output(nullptr), _min_max(nullptr) + : _input(nullptr), _output(nullptr) { } -void NEDequantizationLayerKernel::configure(const ITensor *input, ITensor *output, const ITensor *min_max) +void NEDequantizationLayerKernel::configure(const ITensor *input, ITensor *output) { - ARM_COMPUTE_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), min_max->info())); + ARM_COMPUTE_ERROR_ON_NULLPTR(input, output); + ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info())); - _input = input; - _output = output; - _min_max = min_max; + _input = input; + _output = output; // Configure kernel window - auto win_config = validate_and_configure_window(input->info(), output->info(), min_max->info()); + auto win_config = validate_and_configure_window(input->info(), output->info()); ARM_COMPUTE_ERROR_THROW_ON(std::get<0>(win_config)); INEKernel::configure(std::get<1>(win_config)); } -Status NEDequantizationLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +Status NEDequantizationLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output) { - ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, min_max)); - ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get(), min_max->clone().get()))); - + ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output)); + ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get()))); return Status{}; } @@ -110,53 +170,18 @@ void NEDequantizationLayerKernel::run(const Window &window, const ThreadInfo &in ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window); - Window window_input_output(window); - window_input_output.set(3, Window::Dimension(0, 1, 1)); - - Window window_min_max; - window_min_max.use_tensor_dimensions(_min_max->info()->tensor_shape()); - window_min_max.set(Window::DimX, Window::Dimension(0, 1, 1)); - - Iterator input(_input, window_input_output); - Iterator output(_output, window_input_output); - Iterator min_max(_min_max, window_min_max); - - execute_window_loop(window_min_max, [&](const Coordinates & id_batch) + switch(_output->info()->data_type()) { - // Get the min and max - const float min = *(reinterpret_cast<const float *>(min_max.ptr()) + 0); - const float max = *(reinterpret_cast<const float *>(min_max.ptr()) + 1); - - const float32x4_t vmin = vdupq_n_f32(min); - const float range = max - min; - const float32x4_t scaling = vdupq_n_f32(range / 255.0f); - - // Uniformly map values to range 8bit integers, i.e. [min, max] -> [0, 255] - execute_window_loop(window_input_output, [&](const Coordinates & id) - { - // Get the input values - const auto input_ptr = reinterpret_cast<const uint8_t *>(input.ptr() + id_batch[1] * _input->info()->strides_in_bytes()[3]); - - const uint8x8_t val_u8 = vld1_u8(input_ptr); - const uint16x8_t val_u16 = vmovl_u8(val_u8); - const uint32x4_t val_u32_low = vmovl_u16(vget_low_u16(val_u16)); - const uint32x4_t val_u32_high = vmovl_u16(vget_high_u16(val_u16)); - float32x4_t val_low = vcvtq_f32_u32(val_u32_low); - float32x4_t val_high = vcvtq_f32_u32(val_u32_high); - - // Dequantize -> (q / 255.0 * range) + min - val_low = vmulq_f32(val_low, scaling); - val_high = vmulq_f32(val_high, scaling); - val_low = vaddq_f32(val_low, vmin); - val_high = vaddq_f32(val_high, vmin); - - const float32x4x2_t dequantized = vuzpq_f32(val_low, val_high); - - // Store the dequantized values - auto output_ptr = reinterpret_cast<float *>(output.ptr() + id_batch[1] * _output->info()->strides_in_bytes()[3]); - vst2q_f32(output_ptr, dequantized); - }, - input, output); - }, - min_max); -}
\ No newline at end of file + case DataType::F32: + run_dequantization<float>(_input, _output, window); + break; +#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC + case DataType::F16: + run_dequantization<float16_t>(_input, _output, window); + break; +#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ + default: + ARM_COMPUTE_ERROR("Unsupported data type."); + } +} +} // namespace arm_compute
\ No newline at end of file diff --git a/src/runtime/CL/functions/CLDequantizationLayer.cpp b/src/runtime/CL/functions/CLDequantizationLayer.cpp index 6f33b2efa9..cdfdfc77ee 100644 --- a/src/runtime/CL/functions/CLDequantizationLayer.cpp +++ b/src/runtime/CL/functions/CLDequantizationLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -21,36 +21,22 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ - #include "arm_compute/runtime/CL/functions/CLDequantizationLayer.h" -#include "arm_compute/core/CL/ICLTensor.h" -#include "arm_compute/runtime/CL/CLScheduler.h" - -using namespace arm_compute; +#include "arm_compute/core/CL/kernels/CLDequantizationLayerKernel.h" +#include "support/ToolchainSupport.h" -CLDequantizationLayer::CLDequantizationLayer() - : _dequantize_kernel() +namespace arm_compute { -} - -Status CLDequantizationLayer::validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +void CLDequantizationLayer::configure(const ICLTensor *input, ICLTensor *output) { - ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_RETURN_ON_ERROR(CLDequantizationLayerKernel::validate(input, output, min_max)); - - return Status{}; -} - -void CLDequantizationLayer::configure(const ICLTensor *input, ICLTensor *output, const ICLTensor *min_max) -{ - ARM_COMPUTE_ERROR_ON_NULLPTR(input, output, min_max); - - _dequantize_kernel.configure(input, output, min_max); + auto k = arm_compute::support::cpp14::make_unique<CLDequantizationLayerKernel>(); + k->configure(input, output); + _kernel = std::move(k); } -void CLDequantizationLayer::run() +Status CLDequantizationLayer::validate(const ITensorInfo *input, const ITensorInfo *output) { - // Run dequantization kernel - CLScheduler::get().enqueue(_dequantize_kernel, false); + return CLDequantizationLayerKernel::validate(input, output); } +} // namespace arm_compute diff --git a/src/runtime/NEON/functions/NEDequantizationLayer.cpp b/src/runtime/NEON/functions/NEDequantizationLayer.cpp index 0627977686..e92b4bfdc4 100644 --- a/src/runtime/NEON/functions/NEDequantizationLayer.cpp +++ b/src/runtime/NEON/functions/NEDequantizationLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -24,34 +24,20 @@ #include "arm_compute/runtime/NEON/functions/NEDequantizationLayer.h" -#include "arm_compute/core/Types.h" -#include "arm_compute/core/Validate.h" -#include "arm_compute/runtime/NEON/NEScheduler.h" +#include "arm_compute/core/NEON/kernels/NEDequantizationLayerKernel.h" +#include "support/ToolchainSupport.h" -using namespace arm_compute; - -NEDequantizationLayer::NEDequantizationLayer() - : _dequantize_kernel() +namespace arm_compute { -} - -Status NEDequantizationLayer::validate(const ITensorInfo *input, const ITensorInfo *output, const ITensorInfo *min_max) +void NEDequantizationLayer::configure(const ITensor *input, ITensor *output) { - ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output, min_max); - ARM_COMPUTE_RETURN_ON_ERROR(NEDequantizationLayerKernel::validate(input, output, min_max)); - - return Status{}; + auto k = arm_compute::support::cpp14::make_unique<NEDequantizationLayerKernel>(); + k->configure(input, output); + _kernel = std::move(k); } -void NEDequantizationLayer::configure(const ITensor *input, ITensor *output, const ITensor *min_max) +Status NEDequantizationLayer::validate(const ITensorInfo *input, const ITensorInfo *output) { - ARM_COMPUTE_ERROR_ON_NULLPTR(input, output, min_max); - - // Configure kernel - _dequantize_kernel.configure(input, output, min_max); + return NEDequantizationLayerKernel::validate(input, output); } - -void NEDequantizationLayer::run() -{ - NEScheduler::get().schedule(&_dequantize_kernel, Window::DimY); -}
\ No newline at end of file +} // namespace arm_compute
\ No newline at end of file diff --git a/tests/benchmark/CL/DequantizationLayer.cpp b/tests/benchmark/CL/DequantizationLayer.cpp index d34034eaa6..1998b1c589 100644 --- a/tests/benchmark/CL/DequantizationLayer.cpp +++ b/tests/benchmark/CL/DequantizationLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -41,8 +41,8 @@ namespace benchmark { namespace { -const auto data_types_src = framework::dataset::make("DataType", { DataType::U8 }); -const auto data_types_dst = framework::dataset::make("DataType", { DataType::F32 }); +const auto data_types_src = framework::dataset::make("DataType", { DataType::QASYMM8 }); +const auto data_types_dst = framework::dataset::make("DataType", { DataType::F16, DataType::F32 }); } // namespace using CLDequantizationLayerFixture = DequantizationLayerFixture<CLTensor, CLDequantizationLayer, CLAccessor>; @@ -53,7 +53,7 @@ REGISTER_FIXTURE_DATA_TEST_CASE(DequantizationLayer, CLDequantizationLayerFixtur framework::DatasetMode::ALL, framework::dataset::combine(framework::dataset::combine(datasets::Small3DShapes(), data_types_src), data_types_dst)); -TEST_SUITE_END() +TEST_SUITE_END() // CL } // namespace benchmark } // namespace test } // namespace arm_compute diff --git a/tests/benchmark/NEON/DequantizationLayer.cpp b/tests/benchmark/NEON/DequantizationLayer.cpp index 9a0a1e71ba..2ffa8a1c3f 100644 --- a/tests/benchmark/NEON/DequantizationLayer.cpp +++ b/tests/benchmark/NEON/DequantizationLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -41,8 +41,12 @@ namespace benchmark { namespace { -const auto data_types_src = framework::dataset::make("DataType", { DataType::U8 }); +const auto data_types_src = framework::dataset::make("DataType", { DataType::QASYMM8 }); +#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC +const auto data_types_dst = framework::dataset::make("DataType", { DataType::F16, DataType::F32 }); +#else /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ const auto data_types_dst = framework::dataset::make("DataType", { DataType::F32 }); +#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ } // namespace using NEDequantizationLayerFixture = DequantizationLayerFixture<Tensor, NEDequantizationLayer, Accessor>; @@ -53,7 +57,7 @@ REGISTER_FIXTURE_DATA_TEST_CASE(DequantizationLayer, NEDequantizationLayerFixtur framework::DatasetMode::ALL, framework::dataset::combine(framework::dataset::combine(datasets::Small3DShapes(), data_types_src), data_types_dst)); -TEST_SUITE_END() +TEST_SUITE_END() // NEON } // namespace benchmark } // namespace test } // namespace arm_compute diff --git a/tests/benchmark/fixtures/DequantizationLayerFixture.h b/tests/benchmark/fixtures/DequantizationLayerFixture.h index 5ea8b2d437..316098b220 100644 --- a/tests/benchmark/fixtures/DequantizationLayerFixture.h +++ b/tests/benchmark/fixtures/DequantizationLayerFixture.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -44,25 +44,18 @@ public: template <typename...> void setup(TensorShape shape, DataType data_type_src, DataType data_type_dst) { - TensorShape shape_min_max = shape; - shape_min_max.set(Window::DimX, 2); - - // Remove Y and Z dimensions and keep the batches - shape_min_max.remove_dimension(1); - shape_min_max.remove_dimension(1); + const QuantizationInfo q_info(0.5f, -10); // Create tensors - src = create_tensor<TensorType>(shape, data_type_src); - dst = create_tensor<TensorType>(shape, data_type_dst); - min_max = create_tensor<TensorType>(shape_min_max, data_type_dst); + src = create_tensor<TensorType>(shape, data_type_src, 1, q_info); + dst = create_tensor<TensorType>(shape, data_type_dst, 1, q_info); // Create and configure function - dequantization_func.configure(&src, &dst, &min_max); + dequantization_func.configure(&src, &dst); // Allocate tensors src.allocator()->allocate(); dst.allocator()->allocate(); - min_max.allocator()->allocate(); } void run() @@ -80,13 +73,11 @@ public: { src.allocator()->free(); dst.allocator()->free(); - min_max.allocator()->free(); } private: TensorType src{}; TensorType dst{}; - TensorType min_max{}; Function dequantization_func{}; }; } // namespace benchmark diff --git a/tests/validation/CL/DequantizationLayer.cpp b/tests/validation/CL/DequantizationLayer.cpp index 5303566922..b1b0d81c6d 100644 --- a/tests/validation/CL/DequantizationLayer.cpp +++ b/tests/validation/CL/DequantizationLayer.cpp @@ -40,107 +40,94 @@ namespace test { namespace validation { -namespace -{ -const auto DequantizationShapes = concat(datasets::Small3DShapes(), - datasets::Small4DShapes()); -} // namespace - TEST_SUITE(CL) TEST_SUITE(DequantizationLayer) // *INDENT-OFF* // clang-format off -DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip( - framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), // Wrong input data type - TensorInfo(TensorShape(16U, 5U, 16U), 1, DataType::U8), // Invalid shape - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), // Wrong output data type - TensorInfo(TensorShape(16U, 16U, 2U, 5U), 1, DataType::U8), // Missmatching shapes - TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::U8), // Shrink window - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), // Valid +DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip( + framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), // Wrong input data type + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Wrong output data type + TensorInfo(TensorShape(16U, 16U, 2U, 5U), 1, DataType::QASYMM8), // Missmatching shapes + TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Valid + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Valid }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), - TensorInfo(TensorShape(16U, 5U, 16U), 1, DataType::U8), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::F32), TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), })), - framework::dataset::make("MinMax",{ TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::U8), - TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::U8), - TensorInfo(TensorShape(2U), 1, DataType::U8), - })), - framework::dataset::make("Expected", { false, false, false, false, false, true})), - input_info, output_info, min_max, expected) + framework::dataset::make("Expected", { false, false, false, true, true})), + input_info, output_info, expected) { - ARM_COMPUTE_EXPECT(bool(CLDequantizationLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false), &min_max.clone()->set_is_resizable(false))) == expected, framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(bool(CLDequantizationLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false))) == expected, framework::LogLevel::ERRORS); } // clang-format on // *INDENT-ON* -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(DequantizationShapes, framework::dataset::make("DataType", DataType::U8)), shape, data_type) +DATA_TEST_CASE(Configuration, + framework::DatasetMode::ALL, + combine(datasets::SmallShapes(), framework::dataset::make("DataType", { DataType::F16, DataType::F32 })), + shape, data_type) { - TensorShape shape_min_max = shape; - shape_min_max.set(Window::DimX, 2); - - // Remove Y and Z dimensions and keep the batches - shape_min_max.remove_dimension(1); - shape_min_max.remove_dimension(1); - // Create tensors - CLTensor src = create_tensor<CLTensor>(shape, data_type); - CLTensor dst = create_tensor<CLTensor>(shape, DataType::F32); - CLTensor min_max = create_tensor<CLTensor>(shape_min_max, DataType::F32); + CLTensor src = create_tensor<CLTensor>(shape, DataType::QASYMM8, 1, QuantizationInfo(0.5f, -10)); + CLTensor dst = create_tensor<CLTensor>(shape, data_type); ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); - ARM_COMPUTE_EXPECT(min_max.info()->is_resizable(), framework::LogLevel::ERRORS); // Create and configure function CLDequantizationLayer dequant_layer; - dequant_layer.configure(&src, &dst, &min_max); + dequant_layer.configure(&src, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); validate(src.info()->valid_region(), valid_region); validate(dst.info()->valid_region(), valid_region); - // Validate valid region of min_max tensor - const ValidRegion valid_region_min_max = shape_to_valid_region(shape_min_max); - validate(min_max.info()->valid_region(), valid_region_min_max); - // Validate padding - const PaddingSize padding = PaddingCalculator(shape.x(), 4).required_padding(); - validate(src.info()->padding(), padding); - validate(dst.info()->padding(), padding); - - // Validate padding of min_max tensor - const PaddingSize padding_min_max = PaddingCalculator(shape_min_max.x(), 2).required_padding(); - validate(min_max.info()->padding(), padding_min_max); + validate(src.info()->padding(), PaddingSize()); + validate(dst.info()->padding(), PaddingSize()); } template <typename T> using CLDequantizationLayerFixture = DequantizationValidationFixture<CLTensor, CLAccessor, CLDequantizationLayer, T>; -TEST_SUITE(Integer) -TEST_SUITE(U8) -FIXTURE_DATA_TEST_CASE(RunSmall, CLDequantizationLayerFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(concat(datasets::Small3DShapes(), datasets::Small4DShapes()), - framework::dataset::make("DataType", DataType::U8))) +TEST_SUITE(FP16) +FIXTURE_DATA_TEST_CASE(RunSmall, CLDequantizationLayerFixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), + framework::dataset::make("DataType", DataType::F16)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +FIXTURE_DATA_TEST_CASE(RunLarge, CLDequantizationLayerFixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), + framework::dataset::make("DataType", DataType::F16)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) +{ + // Validate output + validate(CLAccessor(_target), _reference); +} +TEST_SUITE_END() // FP16 + +TEST_SUITE(FP32) +FIXTURE_DATA_TEST_CASE(RunSmall, CLDequantizationLayerFixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), + framework::dataset::make("DataType", DataType::F32)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) { // Validate output validate(CLAccessor(_target), _reference); } -FIXTURE_DATA_TEST_CASE(RunLarge, CLDequantizationLayerFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(concat(datasets::Large3DShapes(), datasets::Large4DShapes()), - framework::dataset::make("DataType", DataType::U8))) +FIXTURE_DATA_TEST_CASE(RunLarge, CLDequantizationLayerFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), + framework::dataset::make("DataType", DataType::F32)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) { // Validate output validate(CLAccessor(_target), _reference); } -TEST_SUITE_END() // U8 -TEST_SUITE_END() // Integer +TEST_SUITE_END() // FP32 TEST_SUITE_END() // DequantizationLayer TEST_SUITE_END() // CL diff --git a/tests/validation/NEON/DequantizationLayer.cpp b/tests/validation/NEON/DequantizationLayer.cpp index 48a6b227c1..0ae20b7b5d 100644 --- a/tests/validation/NEON/DequantizationLayer.cpp +++ b/tests/validation/NEON/DequantizationLayer.cpp @@ -42,8 +42,11 @@ namespace validation { namespace { -/** Tolerance for float operations */ -constexpr AbsoluteTolerance<float> tolerance_f32(0.001f); +#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC +const auto data_types = framework::dataset::make("DataType", { DataType::F16, DataType::F32 }); +#else /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ +const auto data_types = framework::dataset::make("DataType", { DataType::F32 }); +#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ } // namespace TEST_SUITE(NEON) @@ -51,96 +54,91 @@ TEST_SUITE(DequantizationLayer) // *INDENT-OFF* // clang-format off -DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip( - framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), // Wrong input data type - TensorInfo(TensorShape(16U, 5U, 16U), 1, DataType::U8), // Invalid shape - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), // Wrong output data type - TensorInfo(TensorShape(16U, 16U, 2U, 5U), 1, DataType::U8), // Missmatching shapes - TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::U8), // Shrink window - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), // Valid - }), - framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), - TensorInfo(TensorShape(16U, 5U, 16U), 1, DataType::U8), - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), - TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::F32), - TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), - })), - framework::dataset::make("MinMax",{ TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::U8), - TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::F32), - TensorInfo(TensorShape(2U), 1, DataType::U8), - TensorInfo(TensorShape(2U), 1, DataType::U8), - })), - framework::dataset::make("Expected", { false, false, false, false, false, true})), - input_info, output_info, min_max, expected) +DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip( + framework::dataset::make("InputInfo", { TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), // Wrong input data type + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Wrong output data type + TensorInfo(TensorShape(16U, 16U, 2U, 5U), 1, DataType::QASYMM8), // Missmatching shapes + TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Valid + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::QASYMM8), // Valid + }), + framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::U8), + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), + TensorInfo(TensorShape(17U, 16U, 16U, 5U), 1, DataType::F32), + TensorInfo(TensorShape(16U, 16U, 16U, 5U), 1, DataType::F32), + })), + framework::dataset::make("Expected", { false, false, false, true, true})), + input_info, output_info, expected) { - ARM_COMPUTE_EXPECT(bool(NEDequantizationLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false), &min_max.clone()->set_is_resizable(false))) == expected, framework::LogLevel::ERRORS); + ARM_COMPUTE_EXPECT(bool(NEDequantizationLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false))) == expected, framework::LogLevel::ERRORS); } // clang-format on // *INDENT-ON* -DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(datasets::Small3DShapes(), framework::dataset::make("DataType", DataType::U8)), shape, data_type) +DATA_TEST_CASE(Configuration, + framework::DatasetMode::ALL, + combine(datasets::SmallShapes(), data_types), + shape, data_type) { - TensorShape shape_min_max = shape; - shape_min_max.set(Window::DimX, 2); - - // Remove Y and Z dimensions and keep the batches - shape_min_max.remove_dimension(1); - shape_min_max.remove_dimension(1); - // Create tensors - Tensor src = create_tensor<Tensor>(shape, data_type); - Tensor dst = create_tensor<Tensor>(shape, DataType::F32); - Tensor min_max = create_tensor<Tensor>(shape_min_max, DataType::F32); + Tensor src = create_tensor<Tensor>(shape, DataType::QASYMM8, 1, QuantizationInfo(0.5f, -10)); + Tensor dst = create_tensor<Tensor>(shape, data_type); ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); - ARM_COMPUTE_EXPECT(min_max.info()->is_resizable(), framework::LogLevel::ERRORS); // Create and configure function NEDequantizationLayer dequant_layer; - dequant_layer.configure(&src, &dst, &min_max); + dequant_layer.configure(&src, &dst); // Validate valid region const ValidRegion valid_region = shape_to_valid_region(shape); validate(src.info()->valid_region(), valid_region); validate(dst.info()->valid_region(), valid_region); - // Validate valid region of min_max tensor - const ValidRegion valid_region_min_max = shape_to_valid_region(shape_min_max); - validate(min_max.info()->valid_region(), valid_region_min_max); - // Validate padding - const PaddingSize padding = PaddingCalculator(shape.x(), 8).required_padding(); - validate(src.info()->padding(), padding); - validate(dst.info()->padding(), padding); - - // Validate padding of min_max tensor - const PaddingSize padding_min_max = PaddingCalculator(shape_min_max.x(), 2).required_padding(); - validate(min_max.info()->padding(), padding_min_max); + validate(src.info()->padding(), PaddingSize()); + validate(dst.info()->padding(), PaddingSize()); } template <typename T> using NEDequantizationLayerFixture = DequantizationValidationFixture<Tensor, Accessor, NEDequantizationLayer, T>; -TEST_SUITE(Integer) -TEST_SUITE(U8) -FIXTURE_DATA_TEST_CASE(RunSmall, NEDequantizationLayerFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(concat(datasets::Small3DShapes(), datasets::Small4DShapes()), - framework::dataset::make("DataType", DataType::U8))) +#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC +TEST_SUITE(FP16) +FIXTURE_DATA_TEST_CASE(RunSmall, NEDequantizationLayerFixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), + framework::dataset::make("DataType", DataType::F16)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) +{ + // Validate output + validate(Accessor(_target), _reference); +} +FIXTURE_DATA_TEST_CASE(RunLarge, NEDequantizationLayerFixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), + framework::dataset::make("DataType", DataType::F16)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) +{ + // Validate output + validate(Accessor(_target), _reference); +} +TEST_SUITE_END() // FP16 +#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */ + +TEST_SUITE(FP32) +FIXTURE_DATA_TEST_CASE(RunSmall, NEDequantizationLayerFixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(datasets::SmallShapes(), + framework::dataset::make("DataType", DataType::F32)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) { // Validate output - validate(Accessor(_target), _reference, tolerance_f32); + validate(Accessor(_target), _reference); } -FIXTURE_DATA_TEST_CASE(RunLarge, NEDequantizationLayerFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(concat(datasets::Large3DShapes(), datasets::Large4DShapes()), - framework::dataset::make("DataType", DataType::U8))) +FIXTURE_DATA_TEST_CASE(RunLarge, NEDequantizationLayerFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(datasets::LargeShapes(), + framework::dataset::make("DataType", DataType::F32)), + framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.1f, 128.0f) }))) { // Validate output - validate(Accessor(_target), _reference, tolerance_f32); + validate(Accessor(_target), _reference); } -TEST_SUITE_END() // U8 -TEST_SUITE_END() // Integer +TEST_SUITE_END() // FP32 TEST_SUITE_END() // DequantizationLayer TEST_SUITE_END() // NEON diff --git a/tests/validation/fixtures/DequantizationLayerFixture.h b/tests/validation/fixtures/DequantizationLayerFixture.h index 0bf3522cd6..2e3712dff2 100644 --- a/tests/validation/fixtures/DequantizationLayerFixture.h +++ b/tests/validation/fixtures/DequantizationLayerFixture.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -47,10 +47,10 @@ class DequantizationValidationFixture : public framework::Fixture { public: template <typename...> - void setup(TensorShape shape, DataType data_type) + void setup(TensorShape shape, DataType data_type, QuantizationInfo qinfo) { - _target = compute_target(shape, data_type); - _reference = compute_reference(shape, data_type); + _target = compute_target(shape, data_type, qinfo); + _reference = compute_reference(shape, data_type, qinfo); } protected: @@ -60,80 +60,28 @@ protected: library->fill_tensor_uniform(tensor, 0); } - template <typename U> - void fill_min_max(U &&tensor) - { - std::mt19937 gen(library->seed()); - std::uniform_real_distribution<float> distribution(-1.0f, 1.0f); - - Window window; - - window.set(0, Window::Dimension(0, tensor.shape()[0], 2)); - - for(unsigned int d = 1; d < tensor.shape().num_dimensions(); ++d) - { - window.set(d, Window::Dimension(0, tensor.shape()[d], 1)); - } - - execute_window_loop(window, [&](const Coordinates & id) - { - const float n1 = distribution(gen); - const float n2 = distribution(gen); - - float min = 0.0f; - float max = 0.0f; - - if(n1 < n2) - { - min = n1; - max = n2; - } - else - { - min = n2; - max = n1; - } - - auto out_ptr = reinterpret_cast<float *>(tensor(id)); - out_ptr[0] = min; - out_ptr[1] = max; - }); - } - - TensorType compute_target(const TensorShape &shape, DataType data_type) + TensorType compute_target(const TensorShape &shape, DataType data_type, QuantizationInfo qinfo) { - TensorShape shape_min_max = shape; - shape_min_max.set(Window::DimX, 2); - - // Remove Y and Z dimensions and keep the batches - shape_min_max.remove_dimension(1); - shape_min_max.remove_dimension(1); - // Create tensors - TensorType src = create_tensor<TensorType>(shape, data_type); - TensorType dst = create_tensor<TensorType>(shape, DataType::F32); - TensorType min_max = create_tensor<TensorType>(shape_min_max, DataType::F32); + TensorType src = create_tensor<TensorType>(shape, DataType::QASYMM8, 1, qinfo); + TensorType dst = create_tensor<TensorType>(shape, data_type); // Create and configure function FunctionType dequantization_layer; - dequantization_layer.configure(&src, &dst, &min_max); + dequantization_layer.configure(&src, &dst); ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS); ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS); - ARM_COMPUTE_EXPECT(min_max.info()->is_resizable(), framework::LogLevel::ERRORS); // Allocate tensors src.allocator()->allocate(); dst.allocator()->allocate(); - min_max.allocator()->allocate(); ARM_COMPUTE_EXPECT(!src.info()->is_resizable(), framework::LogLevel::ERRORS); ARM_COMPUTE_EXPECT(!dst.info()->is_resizable(), framework::LogLevel::ERRORS); - ARM_COMPUTE_EXPECT(!min_max.info()->is_resizable(), framework::LogLevel::ERRORS); // Fill tensors fill(AccessorType(src)); - fill_min_max(AccessorType(min_max)); // Compute function dequantization_layer.run(); @@ -141,28 +89,19 @@ protected: return dst; } - SimpleTensor<float> compute_reference(const TensorShape &shape, DataType data_type) + SimpleTensor<T> compute_reference(const TensorShape &shape, DataType data_type, QuantizationInfo qinfo) { - TensorShape shape_min_max = shape; - shape_min_max.set(Window::DimX, 2); - - // Remove Y and Z dimensions and keep the batches - shape_min_max.remove_dimension(1); - shape_min_max.remove_dimension(1); - // Create reference - SimpleTensor<T> src{ shape, data_type }; - SimpleTensor<float> min_max{ shape_min_max, data_type }; + SimpleTensor<uint8_t> src{ shape, DataType::QASYMM8, 1, qinfo }; // Fill reference fill(src); - fill_min_max(min_max); - return reference::dequantization_layer<T>(src, min_max); + return reference::dequantization_layer<T>(src); } - TensorType _target{}; - SimpleTensor<float> _reference{}; + TensorType _target{}; + SimpleTensor<T> _reference{}; }; } // namespace validation } // namespace test diff --git a/tests/validation/reference/DequantizationLayer.cpp b/tests/validation/reference/DequantizationLayer.cpp index 33096a1d81..df50c14ec7 100644 --- a/tests/validation/reference/DequantizationLayer.cpp +++ b/tests/validation/reference/DequantizationLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -31,36 +31,24 @@ namespace validation { namespace reference { -template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type> -SimpleTensor<float> dequantization_layer(const SimpleTensor<T> &src, const SimpleTensor<float> &min_max) +template <typename T> +SimpleTensor<T> dequantization_layer(const SimpleTensor<uint8_t> &src) { - // Create reference - SimpleTensor<float> dst{ src.shape(), DataType::F32 }; + const DataType dst_data_type = std::is_same<T, float>::value ? DataType::F32 : DataType::F16; + const QuantizationInfo &quantization_info = src.quantization_info(); - // Compute reference - const int width = src.shape().x(); - const int height = src.shape().y(); - const int depth = src.shape().z(); - const int stride_w = width * height * depth; - const int num_batches = min_max.shape().total_size_upper(1); + SimpleTensor<T> dst{ src.shape(), dst_data_type }; - for(int k = 0; k < num_batches; ++k) + for(int i = 0; i < src.num_elements(); ++i) { - const float min = min_max[k * 2 + 0]; - const float max = min_max[k * 2 + 1]; - const float range = max - min; - const float scaling = range / 255.0f; - - for(int i = 0; i < stride_w; ++i) - { - dst[i + k * stride_w] = (static_cast<float>(src[i + k * stride_w]) * scaling) + min; - } + dst[i] = static_cast<T>(quantization_info.dequantize(src[i])); } return dst; } -template SimpleTensor<float> dequantization_layer(const SimpleTensor<uint8_t> &src, const SimpleTensor<float> &min_max); +template SimpleTensor<half> dequantization_layer(const SimpleTensor<uint8_t> &src); +template SimpleTensor<float> dequantization_layer(const SimpleTensor<uint8_t> &src); } // namespace reference } // namespace validation } // namespace test diff --git a/tests/validation/reference/DequantizationLayer.h b/tests/validation/reference/DequantizationLayer.h index 1a8adcf9d8..1d0e54b442 100644 --- a/tests/validation/reference/DequantizationLayer.h +++ b/tests/validation/reference/DequantizationLayer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -35,8 +35,8 @@ namespace validation { namespace reference { -template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0> -SimpleTensor<float> dequantization_layer(const SimpleTensor<T> &src, const SimpleTensor<float> &min_max); +template <typename T> +SimpleTensor<T> dequantization_layer(const SimpleTensor<uint8_t> &src); } // namespace reference } // namespace validation } // namespace test |