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>

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;
 }