COMPMID-421: Added FP16 support in BatchNormalizationLayer.

Change-Id: I7142e0e8466ef79e016ae56d285e8e9291573e52
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/79814
Reviewed-by: Moritz Pflanzer <moritz.pflanzer@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>

4 files changed, 145 insertions, 59 deletions

diff --git a/tests/NEON/Helper.h b/tests/NEON/Helper.h
index 5b0f750fca..9e60a48ecd 100644
--- a/tests/NEON/Helper.h
+++ b/tests/NEON/Helper.h
@@ -25,8 +25,10 @@
 #define __ARM_COMPUTE_TEST_NEON_HELPER_H__
 
 #include "arm_compute/runtime/Array.h"
+#include "tests/Globals.h"
 
 #include <algorithm>
+#include <array>
 #include <vector>
 
 namespace arm_compute
@@ -44,6 +46,20 @@ Array<T> create_array(const std::vector<T> &v)
 
     return array;
 }
+
+template <typename D, typename T, typename... Ts>
+void fill_tensors(D &&dist, std::initializer_list<int> seeds, T &&tensor, Ts &&... other_tensors)
+{
+    const std::array < T, 1 + sizeof...(Ts) > tensors{ { std::forward<T>(tensor), std::forward<Ts>(other_tensors)... } };
+    std::vector<int> vs(seeds);
+    ARM_COMPUTE_ERROR_ON(vs.size() != tensors.size());
+    int k = 0;
+    for(auto tp : tensors)
+    {
+        library->fill(Accessor(*tp), std::forward<D>(dist), vs[k++]);
+    }
+}
+
 } // namespace test
 } // namespace arm_compute
 #endif /* __ARM_COMPUTE_TEST_NEON_HELPER_H__ */
diff --git a/tests/validation/Helpers.h b/tests/validation/Helpers.h
index 2793c22147..8d70de6958 100644
--- a/tests/validation/Helpers.h
+++ b/tests/validation/Helpers.h
@@ -25,11 +25,13 @@
 #define __ARM_COMPUTE_TEST_VALIDATION_HELPERS_H__
 
 #include "arm_compute/core/Types.h"
+#include "tests/Globals.h"
 #include "tests/ILutAccessor.h"
 #include "tests/Types.h"
 #include "tests/validation/ValidationUserConfiguration.h"
 #include "tests/validation/half.h"
 
+#include <array>
 #include <random>
 #include <type_traits>
 #include <utility>
@@ -41,6 +43,27 @@ namespace test
 {
 namespace validation
 {
+/** Helper function to fill one or more tensors with the uniform distribution with int values.
+ *
+ * @param[in]     dist          Distribution to be used to get the values for the tensor.
+ * @param[in]     seeds         List of seeds to be used to fill each tensor.
+ * @param[in,out] tensor        Tensor to be initialized with the values of the distribution.
+ * @param[in,out] other_tensors (Optional) One or more tensors to be filled.
+ *
+ */
+template <typename D, typename T, typename... Ts>
+void fill_tensors(D &&dist, std::initializer_list<int> seeds, T &&tensor, Ts &&... other_tensors)
+{
+    const std::array < T, 1 + sizeof...(Ts) > tensors{ { std::forward<T>(tensor), std::forward<Ts>(other_tensors)... } };
+    std::vector<int> vs(seeds);
+    ARM_COMPUTE_ERROR_ON(vs.size() != tensors.size());
+    int k = 0;
+    for(auto tp : tensors)
+    {
+        library->fill(*tp, std::forward<D>(dist), vs[k++]);
+    }
+}
+
 /** Helper function to get the testing range for each activation layer.
  *
  * @param[in] activation           Activation function to test.
diff --git a/tests/validation/NEON/BatchNormalizationLayer.cpp b/tests/validation/NEON/BatchNormalizationLayer.cpp
index 279257d071..9898beb7db 100644
--- a/tests/validation/NEON/BatchNormalizationLayer.cpp
+++ b/tests/validation/NEON/BatchNormalizationLayer.cpp
@@ -25,6 +25,7 @@
 #include "TypePrinter.h"
 #include "dataset/BatchNormalizationLayerDataset.h"
 #include "tests/Globals.h"
+#include "tests/NEON/Helper.h"
 #include "tests/Utils.h"
 #include "tests/validation/Helpers.h"
 #include "validation/Datasets.h"
@@ -41,9 +42,12 @@ using namespace arm_compute::test::validation;
 
 namespace
 {
-const float tolerance_f    = 1e-05; /**< Tolerance value for comparing reference's output against floating point implementation's output */
-const float tolerance_qs8  = 6;     /**< Tolerance value for comparing reference's output against quantized implementation's output */
-const float tolerance_qs16 = 6;     /**< Tolerance value for comparing reference's output against quantized implementation's output */
+const float tolerance_qs8  = 6;      /**< Tolerance value for comparing reference's output against quantized implementation's output */
+const float tolerance_qs16 = 6;      /**< Tolerance value for comparing reference's output against quantized implementation's output */
+const float tolerance_f32  = 1e-05f; /**< Tolerance value for comparing reference's output against floating point implementation's output */
+#ifdef ARM_COMPUTE_ENABLE_FP16
+const float tolerance_f16 = 0.01f; /**< Tolerance value for comparing reference's output against half precision floating point implementation's output */
+#endif                             /* ARM_COMPUTE_ENABLE_FP16 */
 
 /** Compute Neon batch normalization function.
  *
@@ -83,38 +87,51 @@ Tensor compute_reference_batch_normalization_layer(const TensorShape &shape0, co
     BOOST_TEST(!gamma.info()->is_resizable());
 
     // Fill tensors
-    if(dt == DataType::F32)
+    switch(dt)
     {
-        float min_bound = 0.f;
-        float max_bound = 0.f;
-        std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<float>();
-        std::uniform_real_distribution<> distribution(min_bound, max_bound);
-        std::uniform_real_distribution<> distribution_var(0, max_bound);
-        library->fill(Accessor(src), distribution, 0);
-        library->fill(Accessor(mean), distribution, 1);
-        library->fill(Accessor(var), distribution_var, 0);
-        library->fill(Accessor(beta), distribution, 3);
-        library->fill(Accessor(gamma), distribution, 4);
-    }
-    else
-    {
-        int min_bound = 0;
-        int max_bound = 0;
-        if(dt == DataType::QS8)
+        case DataType::QS8:
+        {
+            const std::pair<int8_t, int8_t> bounds = get_batchnormalization_layer_test_bounds<int8_t>(fixed_point_position);
+            std::uniform_int_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_int_distribution<> distribution_var(0, bounds.second);
+            test::fill_tensors(distribution, { 0, 1, 3, 4 }, &src, &mean, &beta, &gamma);
+            test::fill_tensors(distribution_var, { 0 }, &var);
+            break;
+        }
+        case DataType::QS16:
+        {
+            const std::pair<int16_t, int16_t> bounds = get_batchnormalization_layer_test_bounds<int16_t>(fixed_point_position);
+            std::uniform_int_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_int_distribution<> distribution_var(0, bounds.second);
+            test::fill_tensors(distribution, { 0, 1, 3, 4 }, &src, &mean, &beta, &gamma);
+            test::fill_tensors(distribution_var, { 0 }, &var);
+            break;
+        }
+#ifdef ARM_COMPUTE_ENABLE_FP16
+        case DataType::F16:
         {
-            std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<int8_t>(fixed_point_position);
+            const std::pair<half_float::half, half_float::half> bounds = get_batchnormalization_layer_test_bounds<half_float::half>();
+            std::uniform_real_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_real_distribution<> distribution_var(0, bounds.second);
+            test::fill_tensors(distribution, { 0, 1, 3, 4 }, &src, &mean, &beta, &gamma);
+            test::fill_tensors(distribution_var, { 0 }, &var);
+            break;
         }
-        else
+#endif /* ARM_COMPUTE_ENABLE_FP16 */
+        case DataType::F32:
         {
-            std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<int16_t>(fixed_point_position);
+            const std::pair<float, float> bounds = get_batchnormalization_layer_test_bounds<float>();
+            std::uniform_real_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_real_distribution<> distribution_var(0, bounds.second);
+            test::fill_tensors(distribution, { 0, 1, 3, 4 }, &src, &mean, &beta, &gamma);
+            test::fill_tensors(distribution_var, { 0 }, &var);
+            break;
+        }
+        default:
+        {
+            ARM_COMPUTE_ERROR("Not supported");
+            break;
         }
-        std::uniform_int_distribution<> distribution(min_bound, max_bound);
-        std::uniform_int_distribution<> distribution_var(0, max_bound);
-        library->fill(Accessor(src), distribution, 0);
-        library->fill(Accessor(mean), distribution, 1);
-        library->fill(Accessor(var), distribution_var, 0);
-        library->fill(Accessor(beta), distribution, 3);
-        library->fill(Accessor(gamma), distribution, 4);
     }
 
     // Compute function
@@ -177,9 +194,28 @@ BOOST_DATA_TEST_CASE(Random,
     RawTensor ref_dst = Reference::compute_reference_batch_normalization_layer(obj.shape0, obj.shape1, dt, obj.epsilon);
 
     // Validate output
-    validate(Accessor(dst), ref_dst, tolerance_f, 0);
+    validate(Accessor(dst), ref_dst, tolerance_f32, 0);
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+#ifdef ARM_COMPUTE_ENABLE_FP16
+BOOST_AUTO_TEST_SUITE(Float16)
+BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
+BOOST_DATA_TEST_CASE(Random,
+                     RandomBatchNormalizationLayerDataset() * boost::unit_test::data::make(DataType::F16),
+                     obj, dt)
+{
+    // Compute function
+    Tensor dst = compute_reference_batch_normalization_layer(obj.shape0, obj.shape1, dt, obj.epsilon);
+
+    // Compute reference
+    RawTensor ref_dst = Reference::compute_reference_batch_normalization_layer(obj.shape0, obj.shape1, dt, obj.epsilon);
+
+    // Validate output
+    validate(Accessor(dst), ref_dst, tolerance_f16, 0);
 }
 BOOST_AUTO_TEST_SUITE_END()
+#endif /* ARM_COMPUTE_ENABLE_FP16 */
 
 BOOST_AUTO_TEST_SUITE(Quantized)
 BOOST_AUTO_TEST_SUITE(QS8)
diff --git a/tests/validation/Reference.cpp b/tests/validation/Reference.cpp
index b7553f3b7b..e9ddea78cb 100644
--- a/tests/validation/Reference.cpp
+++ b/tests/validation/Reference.cpp
@@ -513,39 +513,50 @@ RawTensor Reference::compute_reference_batch_normalization_layer(const TensorSha
     RawTensor ref_beta(shape1, dt, 1, fixed_point_position);
     RawTensor ref_gamma(shape1, dt, 1, fixed_point_position);
 
-    // Fill tensors with values from -1 to 1.
-    if(dt == DataType::F32)
-    {
-        float min_bound = 0.f;
-        float max_bound = 0.f;
-        std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<float>();
-        std::uniform_real_distribution<> distribution(min_bound, max_bound);
-        std::uniform_real_distribution<> distribution_var(0, max_bound);
-        library->fill(ref_src, distribution, 0);
-        library->fill(ref_mean, distribution, 1);
-        library->fill(ref_var, distribution_var, 0);
-        library->fill(ref_beta, distribution, 3);
-        library->fill(ref_gamma, distribution, 4);
-    }
-    else
+    // Fill tensors
+    switch(dt)
     {
-        int min_bound = 0;
-        int max_bound = 0;
-        if(dt == DataType::QS8)
+        case DataType::QS8:
         {
-            std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<int8_t>(fixed_point_position);
+            const std::pair<int8_t, int8_t> bounds = get_batchnormalization_layer_test_bounds<int8_t>(fixed_point_position);
+            std::uniform_int_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_int_distribution<> distribution_var(0, bounds.second);
+            fill_tensors(distribution, { 0, 1, 3, 4 }, &ref_src, &ref_mean, &ref_beta, &ref_gamma);
+            fill_tensors(distribution_var, { 0 }, &ref_var);
+            break;
         }
-        else
+        case DataType::QS16:
         {
-            std::tie(min_bound, max_bound) = get_batchnormalization_layer_test_bounds<int16_t>(fixed_point_position);
+            const std::pair<int16_t, int16_t> bounds = get_batchnormalization_layer_test_bounds<int16_t>(fixed_point_position);
+            std::uniform_int_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_int_distribution<> distribution_var(0, bounds.second);
+            fill_tensors(distribution, { 0, 1, 3, 4 }, &ref_src, &ref_mean, &ref_beta, &ref_gamma);
+            fill_tensors(distribution_var, { 0 }, &ref_var);
+            break;
+        }
+        case DataType::F16:
+        {
+            const std::pair<half_float::half, half_float::half> bounds = get_batchnormalization_layer_test_bounds<half_float::half>();
+            std::uniform_real_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_real_distribution<> distribution_var(0, bounds.second);
+            fill_tensors(distribution, { 0, 1, 3, 4 }, &ref_src, &ref_mean, &ref_beta, &ref_gamma);
+            fill_tensors(distribution_var, { 0 }, &ref_var);
+            break;
+        }
+        case DataType::F32:
+        {
+            const std::pair<float, float> bounds = get_batchnormalization_layer_test_bounds<float>();
+            std::uniform_real_distribution<> distribution(bounds.first, bounds.second);
+            std::uniform_real_distribution<> distribution_var(0, bounds.second);
+            fill_tensors(distribution, { 0, 1, 3, 4 }, &ref_src, &ref_mean, &ref_beta, &ref_gamma);
+            fill_tensors(distribution_var, { 0 }, &ref_var);
+            break;
+        }
+        default:
+        {
+            ARM_COMPUTE_ERROR("Not supported");
+            break;
         }
-        std::uniform_int_distribution<> distribution(min_bound, max_bound);
-        std::uniform_int_distribution<> distribution_var(0, max_bound);
-        library->fill(ref_src, distribution, 0);
-        library->fill(ref_mean, distribution, 1);
-        library->fill(ref_var, distribution_var, 0);
-        library->fill(ref_beta, distribution, 3);
-        library->fill(ref_gamma, distribution, 4);
     }
 
     // Compute reference