diff options
author | Michele Di Giorgio <michele.digiorgio@arm.com> | 2019-08-28 16:27:26 +0100 |
---|---|---|
committer | Pablo Marquez <pablo.tello@arm.com> | 2019-09-04 14:32:18 +0000 |
commit | 4aff98fcfd3c736115f3983dc448c3280e570841 (patch) | |
tree | fd9ce801272b0a1aec9f14fbe89923760a5c2182 /tests/validation | |
parent | 49be2e32e697f3b7a124018bc3cee91adb5f9478 (diff) | |
download | ComputeLibrary-4aff98fcfd3c736115f3983dc448c3280e570841.tar.gz |
COMPMID-2247: Extend support of CLBoundingBoxTransform for QUANT16_ASYMM
Change-Id: I8af7a382c0bccf55cf7f4a64f46ce9e6cd965afe
Signed-off-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Reviewed-on: https://review.mlplatform.org/c/1833
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Pablo Marquez <pablo.tello@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Diffstat (limited to 'tests/validation')
19 files changed, 222 insertions, 105 deletions
diff --git a/tests/validation/CL/BoundingBoxTransform.cpp b/tests/validation/CL/BoundingBoxTransform.cpp index b6334b5868..2491e185d8 100644 --- a/tests/validation/CL/BoundingBoxTransform.cpp +++ b/tests/validation/CL/BoundingBoxTransform.cpp @@ -46,6 +46,8 @@ AbsoluteTolerance<float> absolute_tolerance_f32(0.001f); RelativeTolerance<half> relative_tolerance_f16(half(0.2)); AbsoluteTolerance<float> absolute_tolerance_f16(half(0.02f)); +constexpr AbsoluteTolerance<uint16_t> tolerance_qasymm16(1); + // *INDENT-OFF* // clang-format off const auto BboxInfoDataset = framework::dataset::make("BboxInfo", { BoundingBoxTransformInfo(20U, 20U, 2U, true), @@ -128,6 +130,21 @@ FIXTURE_DATA_TEST_CASE(BoundingBox, CLBoundingBoxTransformFixture<half>, framewo TEST_SUITE_END() // FP16 TEST_SUITE_END() // Float +template <typename T> +using CLBoundingBoxTransformQuantizedFixture = BoundingBoxTransformQuantizedFixture<CLTensor, CLAccessor, CLBoundingBoxTransform, T>; + +TEST_SUITE(Quantized) +TEST_SUITE(QASYMM16) +FIXTURE_DATA_TEST_CASE(BoundingBox, CLBoundingBoxTransformQuantizedFixture<uint16_t>, framework::DatasetMode::ALL, + combine(combine(combine(DeltaDataset, BboxInfoDataset), framework::dataset::make("DataType", { DataType::QASYMM16 })), + framework::dataset::make("DeltasQuantInfo", { QuantizationInfo(1.f / 255.f, 127) }))) +{ + // Validate output + validate(CLAccessor(_target), _reference, tolerance_qasymm16); +} +TEST_SUITE_END() // QASYMM16 +TEST_SUITE_END() // Quantized + TEST_SUITE_END() // BBoxTransform TEST_SUITE_END() // CL } // namespace validation diff --git a/tests/validation/Helpers.cpp b/tests/validation/Helpers.cpp index a811cabf56..4158793295 100644 --- a/tests/validation/Helpers.cpp +++ b/tests/validation/Helpers.cpp @@ -132,6 +132,7 @@ SimpleTensor<float> convert_from_asymmetric(const SimpleTensor<uint16_t> &src) return dst; } +template <> SimpleTensor<uint8_t> convert_to_asymmetric(const SimpleTensor<float> &src, const QuantizationInfo &quantization_info) { SimpleTensor<uint8_t> dst{ src.shape(), DataType::QASYMM8, 1, quantization_info }; @@ -145,6 +146,19 @@ SimpleTensor<uint8_t> convert_to_asymmetric(const SimpleTensor<float> &src, cons } template <> +SimpleTensor<uint16_t> convert_to_asymmetric(const SimpleTensor<float> &src, const QuantizationInfo &quantization_info) +{ + SimpleTensor<uint16_t> dst{ src.shape(), DataType::QASYMM16, 1, quantization_info }; + const UniformQuantizationInfo &qinfo = quantization_info.uniform(); + + for(int i = 0; i < src.num_elements(); ++i) + { + dst[i] = quantize_qasymm16(src[i], qinfo); + } + return dst; +} + +template <> SimpleTensor<int16_t> convert_to_symmetric(const SimpleTensor<float> &src, const QuantizationInfo &quantization_info) { SimpleTensor<int16_t> dst{ src.shape(), DataType::QSYMM16, 1, quantization_info }; diff --git a/tests/validation/Helpers.h b/tests/validation/Helpers.h index 0d6515b5c5..2ee2dc7aab 100644 --- a/tests/validation/Helpers.h +++ b/tests/validation/Helpers.h @@ -200,7 +200,16 @@ SimpleTensor<float> convert_from_asymmetric(const SimpleTensor<uint16_t> &src); * * @return Quantized tensor. */ -SimpleTensor<uint8_t> convert_to_asymmetric(const SimpleTensor<float> &src, const QuantizationInfo &quantization_info); +template <typename T> +SimpleTensor<T> convert_to_asymmetric(const SimpleTensor<float> &src, const QuantizationInfo &quantization_info); + +/** Convert quantized simple tensor into float using tensor quantization information. + * + * @param[in] src Quantized tensor. + * + * @return Float tensor. + */ +SimpleTensor<float> convert_from_asymmetric(const SimpleTensor<uint16_t> &src); /** Convert quantized simple tensor into float using tensor quantization information. * diff --git a/tests/validation/fixtures/BoundingBoxTransformFixture.h b/tests/validation/fixtures/BoundingBoxTransformFixture.h index b71da8e97d..5e4c598f73 100644 --- a/tests/validation/fixtures/BoundingBoxTransformFixture.h +++ b/tests/validation/fixtures/BoundingBoxTransformFixture.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -40,28 +40,117 @@ namespace test { namespace validation { +namespace +{ +std::vector<float> generate_deltas(std::vector<float> &boxes, const TensorShape &image_shape, size_t num_boxes, size_t num_classes, std::mt19937 &gen) +{ + std::vector<float> deltas(num_boxes * 4 * num_classes); + + std::uniform_int_distribution<> dist_x1(0, image_shape[0] - 1); + std::uniform_int_distribution<> dist_y1(0, image_shape[1] - 1); + std::uniform_int_distribution<> dist_w(1, image_shape[0]); + std::uniform_int_distribution<> dist_h(1, image_shape[1]); + + for(size_t i = 0; i < num_boxes; ++i) + { + const float ex_width = boxes[4 * i + 2] - boxes[4 * i] + 1.f; + const float ex_height = boxes[4 * i + 3] - boxes[4 * i + 1] + 1.f; + const float ex_ctr_x = boxes[4 * i] + 0.5f * ex_width; + const float ex_ctr_y = boxes[4 * i + 1] + 0.5f * ex_height; + + for(size_t j = 0; j < num_classes; ++j) + { + const float x1 = dist_x1(gen); + const float y1 = dist_y1(gen); + const float width = dist_w(gen); + const float height = dist_h(gen); + const float ctr_x = x1 + 0.5f * width; + const float ctr_y = y1 + 0.5f * height; + + deltas[4 * num_classes * i + 4 * j] = (ctr_x - ex_ctr_x) / ex_width; + deltas[4 * num_classes * i + 4 * j + 1] = (ctr_y - ex_ctr_y) / ex_height; + deltas[4 * num_classes * i + 4 * j + 2] = log(width / ex_width); + deltas[4 * num_classes * i + 4 * j + 3] = log(height / ex_height); + } + } + return deltas; +} + +std::vector<float> generate_boxes(const TensorShape &image_shape, size_t num_boxes, std::mt19937 &gen) +{ + std::vector<float> boxes(num_boxes * 4); + + std::uniform_int_distribution<> dist_x1(0, image_shape[0] - 1); + std::uniform_int_distribution<> dist_y1(0, image_shape[1] - 1); + std::uniform_int_distribution<> dist_w(1, image_shape[0]); + std::uniform_int_distribution<> dist_h(1, image_shape[1]); + + for(size_t i = 0; i < num_boxes; ++i) + { + boxes[4 * i] = dist_x1(gen); + boxes[4 * i + 1] = dist_y1(gen); + boxes[4 * i + 2] = boxes[4 * i] + dist_w(gen) - 1; + boxes[4 * i + 3] = boxes[4 * i + 1] + dist_h(gen) - 1; + } + return boxes; +} +} // namespace + template <typename TensorType, typename AccessorType, typename FunctionType, typename T> -class BoundingBoxTransformFixture : public framework::Fixture +class BoundingBoxTransformGenericFixture : public framework::Fixture { public: + using TDeltas = typename std::conditional<std::is_same<typename std::decay<T>::type, uint16_t>::value, uint8_t, T>::type; + template <typename...> - void setup(TensorShape deltas_shape, const BoundingBoxTransformInfo &info, DataType data_type) + void setup(TensorShape deltas_shape, const BoundingBoxTransformInfo &info, DataType data_type, QuantizationInfo deltas_qinfo) { + const bool is_qasymm16 = data_type == DataType::QASYMM16; + _data_type_deltas = (is_qasymm16) ? DataType::QASYMM8 : data_type; + _boxes_qinfo = (is_qasymm16) ? QuantizationInfo(.125f, 0) : QuantizationInfo(); + std::mt19937 gen_target(library->seed()); - _target = compute_target(deltas_shape, data_type, info, gen_target); + _target = compute_target(deltas_shape, data_type, info, gen_target, deltas_qinfo); std::mt19937 gen_reference(library->seed()); - _reference = compute_reference(deltas_shape, data_type, info, gen_reference); + _reference = compute_reference(deltas_shape, data_type, info, gen_reference, deltas_qinfo); } protected: + template <typename data_type, typename U> + void fill(U &&tensor, std::vector<float> values) + { + data_type *data_ptr = reinterpret_cast<data_type *>(tensor.data()); + switch(tensor.data_type()) + { + case DataType::QASYMM8: + for(size_t i = 0; i < values.size(); ++i) + { + data_ptr[i] = quantize_qasymm8(values[i], tensor.quantization_info()); + } + break; + case DataType::QASYMM16: + for(size_t i = 0; i < values.size(); ++i) + { + data_ptr[i] = quantize_qasymm16(values[i], tensor.quantization_info()); + } + break; + default: + for(size_t i = 0; i < values.size(); ++i) + { + data_ptr[i] = static_cast<data_type>(values[i]); + } + } + } + TensorType compute_target(const TensorShape &deltas_shape, DataType data_type, - const BoundingBoxTransformInfo &bbox_info, std::mt19937 &gen) + const BoundingBoxTransformInfo &bbox_info, std::mt19937 &gen, + QuantizationInfo deltas_qinfo) { // Create tensors TensorShape boxes_shape(4, deltas_shape[1]); - TensorType deltas = create_tensor<TensorType>(deltas_shape, data_type); - TensorType boxes = create_tensor<TensorType>(boxes_shape, data_type); + TensorType deltas = create_tensor<TensorType>(deltas_shape, _data_type_deltas, 1, deltas_qinfo); + TensorType boxes = create_tensor<TensorType>(boxes_shape, data_type, 1, _boxes_qinfo); TensorType pred_boxes; // Create and configure function @@ -81,9 +170,11 @@ protected: ARM_COMPUTE_EXPECT(!boxes.info()->is_resizable(), framework::LogLevel::ERRORS); // Fill tensors - TensorShape img_shape(bbox_info.scale() * bbox_info.img_width(), bbox_info.scale() * bbox_info.img_height()); - generate_boxes(AccessorType(boxes), img_shape, boxes_shape[1], gen); - generate_deltas(AccessorType(deltas), AccessorType(boxes), img_shape, deltas_shape[1], deltas_shape[0] / 4, gen); + TensorShape img_shape(bbox_info.scale() * bbox_info.img_width(), bbox_info.scale() * bbox_info.img_height()); + std::vector<float> boxes_vec = generate_boxes(img_shape, boxes_shape[1], gen); + std::vector<float> deltas_vec = generate_deltas(boxes_vec, img_shape, deltas_shape[1], deltas_shape[0] / 4, gen); + fill<T>(AccessorType(boxes), boxes_vec); + fill<TDeltas>(AccessorType(deltas), deltas_vec); // Compute function bbox_transform.run(); @@ -93,80 +184,56 @@ protected: SimpleTensor<T> compute_reference(const TensorShape &deltas_shape, DataType data_type, - const BoundingBoxTransformInfo &bbox_info, std::mt19937 &gen) + const BoundingBoxTransformInfo &bbox_info, + std::mt19937 &gen, + QuantizationInfo deltas_qinfo) { // Create reference tensor - TensorShape boxes_shape(4, deltas_shape[1]); - SimpleTensor<T> boxes{ boxes_shape, data_type }; - SimpleTensor<T> deltas{ deltas_shape, data_type }; + TensorShape boxes_shape(4, deltas_shape[1]); + SimpleTensor<T> boxes{ boxes_shape, data_type, 1, _boxes_qinfo }; + SimpleTensor<TDeltas> deltas{ deltas_shape, _data_type_deltas, 1, deltas_qinfo }; // Fill reference tensor - TensorShape img_shape(bbox_info.scale() * bbox_info.img_width(), bbox_info.scale() * bbox_info.img_height()); - generate_boxes(boxes, img_shape, boxes_shape[1], gen); - generate_deltas(deltas, boxes, img_shape, deltas_shape[1], deltas_shape[0] / 4, gen); + TensorShape img_shape(bbox_info.scale() * bbox_info.img_width(), bbox_info.scale() * bbox_info.img_height()); + std::vector<float> boxes_vec = generate_boxes(img_shape, boxes_shape[1], gen); + std::vector<float> deltas_vec = generate_deltas(boxes_vec, img_shape, deltas_shape[1], deltas_shape[0] / 4, gen); + fill<T>(boxes, boxes_vec); + fill<TDeltas>(deltas, deltas_vec); return reference::bounding_box_transform(boxes, deltas, bbox_info); } - TensorType _target{}; - SimpleTensor<T> _reference{}; + TensorType _target{}; + SimpleTensor<T> _reference{}; + DataType _data_type_deltas{}; + QuantizationInfo _boxes_qinfo{}; private: - template <typename U> - void generate_deltas(U &&deltas, U &&boxes, const TensorShape &image_shape, size_t num_boxes, size_t num_classes, std::mt19937 &gen) - { - T *deltas_ptr = static_cast<T *>(deltas.data()); - T *boxes_ptr = static_cast<T *>(boxes.data()); - - std::uniform_int_distribution<> dist_x1(0, image_shape[0] - 1); - std::uniform_int_distribution<> dist_y1(0, image_shape[1] - 1); - std::uniform_int_distribution<> dist_w(1, image_shape[0]); - std::uniform_int_distribution<> dist_h(1, image_shape[1]); - - for(size_t i = 0; i < num_boxes; ++i) - { - const T ex_width = boxes_ptr[4 * i + 2] - boxes_ptr[4 * i] + T(1); - const T ex_height = boxes_ptr[4 * i + 3] - boxes_ptr[4 * i + 1] + T(1); - const T ex_ctr_x = boxes_ptr[4 * i] + T(0.5) * ex_width; - const T ex_ctr_y = boxes_ptr[4 * i + 1] + T(0.5) * ex_height; - - for(size_t j = 0; j < num_classes; ++j) - { - const T x1 = T(dist_x1(gen)); - const T y1 = T(dist_y1(gen)); - const T width = T(dist_w(gen)); - const T height = T(dist_h(gen)); - const T ctr_x = x1 + T(0.5) * width; - const T ctr_y = y1 + T(0.5) * height; - - deltas_ptr[4 * num_classes * i + 4 * j] = (ctr_x - ex_ctr_x) / ex_width; - deltas_ptr[4 * num_classes * i + 4 * j + 1] = (ctr_y - ex_ctr_y) / ex_height; - deltas_ptr[4 * num_classes * i + 4 * j + 2] = log(width / ex_width); - deltas_ptr[4 * num_classes * i + 4 * j + 3] = log(height / ex_height); - } - } - } +}; - template <typename U> - void generate_boxes(U &&boxes, const TensorShape &image_shape, size_t num_boxes, std::mt19937 &gen) +template <typename TensorType, typename AccessorType, typename FunctionType, typename T> +class BoundingBoxTransformFixture : public BoundingBoxTransformGenericFixture<TensorType, AccessorType, FunctionType, T> +{ +public: + template <typename...> + void setup(TensorShape deltas_shape, const BoundingBoxTransformInfo &info, DataType data_type) { - T *boxes_ptr = (T *)boxes.data(); + BoundingBoxTransformGenericFixture<TensorType, AccessorType, FunctionType, T>::setup(deltas_shape, info, data_type, QuantizationInfo()); + } - std::uniform_int_distribution<> dist_x1(0, image_shape[0] - 1); - std::uniform_int_distribution<> dist_y1(0, image_shape[1] - 1); - std::uniform_int_distribution<> dist_w(1, image_shape[0]); - std::uniform_int_distribution<> dist_h(1, image_shape[1]); +private: +}; - for(size_t i = 0; i < num_boxes; ++i) - { - boxes_ptr[4 * i] = dist_x1(gen); - boxes_ptr[4 * i + 1] = dist_y1(gen); - boxes_ptr[4 * i + 2] = boxes_ptr[4 * i] + dist_w(gen) - 1; - boxes_ptr[4 * i + 3] = boxes_ptr[4 * i + 1] + dist_h(gen) - 1; - } +template <typename TensorType, typename AccessorType, typename FunctionType, typename T> +class BoundingBoxTransformQuantizedFixture : public BoundingBoxTransformGenericFixture<TensorType, AccessorType, FunctionType, T> +{ +public: + template <typename...> + void setup(TensorShape deltas_shape, const BoundingBoxTransformInfo &info, DataType data_type, QuantizationInfo deltas_qinfo) + { + BoundingBoxTransformGenericFixture<TensorType, AccessorType, FunctionType, T>::setup(deltas_shape, info, data_type, deltas_qinfo); } }; - } // namespace validation } // namespace test } // namespace arm_compute diff --git a/tests/validation/reference/ActivationLayer.cpp b/tests/validation/reference/ActivationLayer.cpp index f573d12df8..6cdba09c75 100644 --- a/tests/validation/reference/ActivationLayer.cpp +++ b/tests/validation/reference/ActivationLayer.cpp @@ -61,7 +61,7 @@ SimpleTensor<uint8_t> activation_layer<uint8_t>(const SimpleTensor<uint8_t> &src SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> dst_tmp = activation_layer<float>(src_tmp, info); - SimpleTensor<uint8_t> dst = convert_to_asymmetric(dst_tmp, dst_qinfo); + SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, dst_qinfo); return dst; } diff --git a/tests/validation/reference/ArithmeticOperations.cpp b/tests/validation/reference/ArithmeticOperations.cpp index abd4f31d72..0ec328ee6a 100644 --- a/tests/validation/reference/ArithmeticOperations.cpp +++ b/tests/validation/reference/ArithmeticOperations.cpp @@ -112,7 +112,7 @@ SimpleTensor<uint8_t> arithmetic_operation(ArithmeticOperation op, const SimpleT BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst); - dst = convert_to_asymmetric(dst_tmp, dst.quantization_info()); + dst = convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info()); return dst; } else diff --git a/tests/validation/reference/BoundingBoxTransform.cpp b/tests/validation/reference/BoundingBoxTransform.cpp index 55dd165b51..e09bcff1c6 100644 --- a/tests/validation/reference/BoundingBoxTransform.cpp +++ b/tests/validation/reference/BoundingBoxTransform.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -36,16 +36,16 @@ namespace validation { namespace reference { -template <typename T> -SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const SimpleTensor<T> &deltas, const BoundingBoxTransformInfo &info) +template <typename T, typename TDeltas> +SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const SimpleTensor<TDeltas> &deltas, const BoundingBoxTransformInfo &info) { - const DataType boxes_data_type = deltas.data_type(); + const DataType boxes_data_type = boxes.data_type(); SimpleTensor<T> pred_boxes(deltas.shape(), boxes_data_type); - const size_t num_classes = deltas.shape()[0] / 4; - const size_t num_boxes = deltas.shape()[1]; - const T *deltas_ptr = deltas.data(); - T *pred_boxes_ptr = pred_boxes.data(); + const size_t num_classes = deltas.shape()[0] / 4; + const size_t num_boxes = deltas.shape()[1]; + const TDeltas *deltas_ptr = deltas.data(); + T *pred_boxes_ptr = pred_boxes.data(); const int img_h = floor(info.img_height() / info.scale() + 0.5f); const int img_w = floor(info.img_width() / info.scale() + 0.5f); @@ -70,15 +70,15 @@ SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const Simpl for(size_t j = 0; j < num_classes; ++j) { // Extract deltas - const size_t start_delta = i * num_classes * class_fields + class_fields * j; - const T dx = deltas_ptr[start_delta] / T(info.weights()[0]); - const T dy = deltas_ptr[start_delta + 1] / T(info.weights()[1]); - T dw = deltas_ptr[start_delta + 2] / T(info.weights()[2]); - T dh = deltas_ptr[start_delta + 3] / T(info.weights()[3]); + const size_t start_delta = i * num_classes * class_fields + class_fields * j; + const TDeltas dx = deltas_ptr[start_delta] / TDeltas(info.weights()[0]); + const TDeltas dy = deltas_ptr[start_delta + 1] / TDeltas(info.weights()[1]); + TDeltas dw = deltas_ptr[start_delta + 2] / TDeltas(info.weights()[2]); + TDeltas dh = deltas_ptr[start_delta + 3] / TDeltas(info.weights()[3]); // Clip dw and dh - dw = std::min(dw, T(info.bbox_xform_clip())); - dh = std::min(dh, T(info.bbox_xform_clip())); + dw = std::min(dw, TDeltas(info.bbox_xform_clip())); + dh = std::min(dh, TDeltas(info.bbox_xform_clip())); // Determine the predictions const T pred_ctr_x = dx * width + ctr_x; @@ -98,6 +98,16 @@ SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const Simpl template SimpleTensor<float> bounding_box_transform(const SimpleTensor<float> &boxes, const SimpleTensor<float> &deltas, const BoundingBoxTransformInfo &info); template SimpleTensor<half> bounding_box_transform(const SimpleTensor<half> &boxes, const SimpleTensor<half> &deltas, const BoundingBoxTransformInfo &info); + +template <> +SimpleTensor<uint16_t> bounding_box_transform(const SimpleTensor<uint16_t> &boxes, const SimpleTensor<uint8_t> &deltas, const BoundingBoxTransformInfo &info) +{ + SimpleTensor<float> boxes_tmp = convert_from_asymmetric(boxes); + SimpleTensor<float> deltas_tmp = convert_from_asymmetric(deltas); + SimpleTensor<float> pred_boxes_tmp = bounding_box_transform<float, float>(boxes_tmp, deltas_tmp, info); + SimpleTensor<uint16_t> pred_boxes = convert_to_asymmetric<uint16_t>(pred_boxes_tmp, boxes.quantization_info()); + return pred_boxes; +} } // namespace reference } // namespace validation } // namespace test diff --git a/tests/validation/reference/BoundingBoxTransform.h b/tests/validation/reference/BoundingBoxTransform.h index 33ef9d984f..dbe2a147e9 100644 --- a/tests/validation/reference/BoundingBoxTransform.h +++ b/tests/validation/reference/BoundingBoxTransform.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -38,8 +38,8 @@ namespace validation { namespace reference { -template <typename T> -SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const SimpleTensor<T> &deltas, const BoundingBoxTransformInfo &info); +template <typename T, typename TDeltas> +SimpleTensor<T> bounding_box_transform(const SimpleTensor<T> &boxes, const SimpleTensor<TDeltas> &deltas, const BoundingBoxTransformInfo &info); } // namespace reference } // namespace validation } // namespace test diff --git a/tests/validation/reference/ElementwiseOperations.cpp b/tests/validation/reference/ElementwiseOperations.cpp index d5a37a0fae..7b39e18bd9 100644 --- a/tests/validation/reference/ElementwiseOperations.cpp +++ b/tests/validation/reference/ElementwiseOperations.cpp @@ -168,7 +168,7 @@ SimpleTensor<uint8_t> arithmetic_operation(ArithmeticOperation op, const SimpleT BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst); - dst = convert_to_asymmetric(dst_tmp, dst.quantization_info()); + dst = convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info()); return dst; } else diff --git a/tests/validation/reference/NormalizePlanarYUVLayer.cpp b/tests/validation/reference/NormalizePlanarYUVLayer.cpp index 563e2a7444..ea0e75a3c7 100644 --- a/tests/validation/reference/NormalizePlanarYUVLayer.cpp +++ b/tests/validation/reference/NormalizePlanarYUVLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -68,7 +68,7 @@ SimpleTensor<uint8_t> normalize_planar_yuv_layer<uint8_t>(const SimpleTensor<uin SimpleTensor<float> mean_tmp = convert_from_asymmetric(mean); SimpleTensor<float> std_tmp = convert_from_asymmetric(std); SimpleTensor<float> dst_tmp = normalize_planar_yuv_layer<float>(src_tmp, mean_tmp, std_tmp); - SimpleTensor<uint8_t> dst = convert_to_asymmetric(dst_tmp, src.quantization_info()); + SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info()); return dst; } diff --git a/tests/validation/reference/PixelWiseMultiplication.cpp b/tests/validation/reference/PixelWiseMultiplication.cpp index 41a919249e..d9895e5ed9 100644 --- a/tests/validation/reference/PixelWiseMultiplication.cpp +++ b/tests/validation/reference/PixelWiseMultiplication.cpp @@ -160,7 +160,7 @@ SimpleTensor<uint8_t> pixel_wise_multiplication(const SimpleTensor<uint8_t> &src SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1); SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2); SimpleTensor<float> dst_tmp = pixel_wise_multiplication<float>(src1_tmp, src2_tmp, scale, convert_policy, rounding_policy, qout); - dst = convert_to_asymmetric(dst_tmp, qout); + dst = convert_to_asymmetric<uint8_t>(dst_tmp, qout); } else { diff --git a/tests/validation/reference/PoolingLayer.cpp b/tests/validation/reference/PoolingLayer.cpp index f4112a486d..34b19ffb4f 100644 --- a/tests/validation/reference/PoolingLayer.cpp +++ b/tests/validation/reference/PoolingLayer.cpp @@ -157,7 +157,7 @@ SimpleTensor<uint8_t> pooling_layer<uint8_t>(const SimpleTensor<uint8_t> &src, c { SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> dst_tmp = pooling_layer<float>(src_tmp, info, output_qinfo); - SimpleTensor<uint8_t> dst = convert_to_asymmetric(dst_tmp, output_qinfo); + SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo); return dst; } diff --git a/tests/validation/reference/ROIAlignLayer.cpp b/tests/validation/reference/ROIAlignLayer.cpp index 8ad78ff915..415b483bc0 100644 --- a/tests/validation/reference/ROIAlignLayer.cpp +++ b/tests/validation/reference/ROIAlignLayer.cpp @@ -209,7 +209,7 @@ SimpleTensor<uint8_t> roi_align_layer(const SimpleTensor<uint8_t> &src, const Si SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> rois_tmp = convert_rois_from_asymmetric(rois); SimpleTensor<float> dst_tmp = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo); - SimpleTensor<uint8_t> dst = convert_to_asymmetric(dst_tmp, output_qinfo); + SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo); return dst; } } // namespace reference diff --git a/tests/validation/reference/Range.cpp b/tests/validation/reference/Range.cpp index c24512fa9d..ad1345425a 100644 --- a/tests/validation/reference/Range.cpp +++ b/tests/validation/reference/Range.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -60,7 +60,7 @@ SimpleTensor<uint8_t> range(SimpleTensor<uint8_t> &dst, float start, const size_ { SimpleTensor<float> dst_tmp{ dst.shape(), DataType::F32, 1 }; generate_range(dst_tmp, start, num_of_elements, step); - return convert_to_asymmetric(dst_tmp, dst.quantization_info()); + return convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info()); } generate_range(dst, start, num_of_elements, step); return dst; diff --git a/tests/validation/reference/ReductionOperation.cpp b/tests/validation/reference/ReductionOperation.cpp index fe128cc6ac..965365db9d 100644 --- a/tests/validation/reference/ReductionOperation.cpp +++ b/tests/validation/reference/ReductionOperation.cpp @@ -281,7 +281,7 @@ SimpleTensor<uint8_t> reduction_operation(const SimpleTensor<uint8_t> &src, cons { SimpleTensor<float> src_f = convert_from_asymmetric(src); SimpleTensor<float> dst_f = reference::reduction_operation<float, float>(src_f, dst_shape, axis, op); - return convert_to_asymmetric(dst_f, src.quantization_info()); + return convert_to_asymmetric<uint8_t>(dst_f, src.quantization_info()); } else { diff --git a/tests/validation/reference/Scale.cpp b/tests/validation/reference/Scale.cpp index 63a2853c66..4405e79263 100644 --- a/tests/validation/reference/Scale.cpp +++ b/tests/validation/reference/Scale.cpp @@ -196,7 +196,7 @@ SimpleTensor<uint8_t> scale(const SimpleTensor<uint8_t> &src, float scale_x, flo SimpleTensor<float> src_tmp = convert_from_asymmetric(src); float constant_border_value_f = dequantize_qasymm8(constant_border_value, src.quantization_info()); SimpleTensor<float> dst_tmp = scale_core<float>(src_tmp, scale_x, scale_y, policy, border_mode, constant_border_value_f, sampling_policy, ceil_policy_scale); - dst = convert_to_asymmetric(dst_tmp, src.quantization_info()); + dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info()); } else { diff --git a/tests/validation/reference/SoftmaxLayer.cpp b/tests/validation/reference/SoftmaxLayer.cpp index f1b94c0a02..fabc62bedb 100644 --- a/tests/validation/reference/SoftmaxLayer.cpp +++ b/tests/validation/reference/SoftmaxLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2018 ARM Limited. + * Copyright (c) 2017-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -90,7 +90,7 @@ SimpleTensor<T> softmax_layer(const SimpleTensor<T> &src, float beta, size_t axi SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> dst_tmp = softmax_layer<float>(src_tmp, beta, axis); - SimpleTensor<T> dst = convert_to_asymmetric(dst_tmp, output_quantization_info); + SimpleTensor<T> dst = convert_to_asymmetric<uint8_t>(dst_tmp, output_quantization_info); return dst; } diff --git a/tests/validation/reference/UpsampleLayer.cpp b/tests/validation/reference/UpsampleLayer.cpp index 8e36ee857e..79d726796a 100644 --- a/tests/validation/reference/UpsampleLayer.cpp +++ b/tests/validation/reference/UpsampleLayer.cpp @@ -93,7 +93,7 @@ SimpleTensor<uint8_t> upsample_layer(const SimpleTensor<uint8_t> &src, const Siz { SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> dst_tmp = upsample_function<float>(src_tmp, info, policy); - dst = convert_to_asymmetric(dst_tmp, src.quantization_info()); + dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info()); } else { diff --git a/tests/validation/reference/YOLOLayer.cpp b/tests/validation/reference/YOLOLayer.cpp index a12f411680..cf5e256cf9 100644 --- a/tests/validation/reference/YOLOLayer.cpp +++ b/tests/validation/reference/YOLOLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 ARM Limited. + * Copyright (c) 2018-2019 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -68,7 +68,7 @@ SimpleTensor<uint8_t> yolo_layer<uint8_t>(const SimpleTensor<uint8_t> &src, cons { SimpleTensor<float> src_tmp = convert_from_asymmetric(src); SimpleTensor<float> dst_tmp = yolo_layer<float>(src_tmp, info, num_classes); - SimpleTensor<uint8_t> dst = convert_to_asymmetric(dst_tmp, src.quantization_info()); + SimpleTensor<uint8_t> dst = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info()); return dst; } |