COMPMID-415: Move NormalizationLayer to new validation

Change-Id: Icf5781c920836fe87d2db27ca3f9cc4eb2bea554
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/80999
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>

7 files changed, 0 insertions, 448 deletions

diff --git a/tests/validation/NEON/NormalizationLayer.cpp b/tests/validation/NEON/NormalizationLayer.cpp
deleted file mode 100644
index 8a5db369d1..0000000000
--- a/tests/validation/NEON/NormalizationLayer.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 2017 ARM Limited.
- *
- * SPDX-License-Identifier: MIT
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#include "NEON/Accessor.h"
-#include "TypePrinter.h"
-#include "tests/Globals.h"
-#include "tests/Utils.h"
-#include "validation/Datasets.h"
-#include "validation/Reference.h"
-#include "validation/Validation.h"
-
-#include "arm_compute/runtime/NEON/functions/NENormalizationLayer.h"
-
-#include <random>
-
-using namespace arm_compute;
-using namespace arm_compute::test;
-using namespace arm_compute::test::validation;
-
-namespace
-{
-/** Define tolerance of the normalization layer depending on values data type.
- *
- * @param[in] dt Data type of the tensors' values.
- *
- * @return Tolerance depending on the data type.
- */
-float normalization_layer_tolerance(DataType dt)
-{
-    switch(dt)
-    {
-        case DataType::QS8:
-            return 2.0f;
-        case DataType::F16:
-            return 0.001f;
-        case DataType::F32:
-            return 1e-05;
-        default:
-            return 0.f;
-    }
-}
-
-/** Compute Neon normalization layer function.
- *
- * @param[in] shape                Shape of the input and output tensors.
- * @param[in] dt                   Data type of input and output tensors.
- * @param[in] norm_info            Normalization Layer information.
- * @param[in] fixed_point_position (Optional) Fixed point position that expresses the number of bits for the fractional part of the number when the tensor's data type is QS8 or QS16 (default = 0).
- *
- * @return Computed output tensor.
- */
-Tensor compute_normalization_layer(const TensorShape &shape, DataType dt, NormalizationLayerInfo norm_info, int fixed_point_position = 0)
-{
-    // Create tensors
-    Tensor src = create_tensor<Tensor>(shape, dt, 1, fixed_point_position);
-    Tensor dst = create_tensor<Tensor>(shape, dt, 1, fixed_point_position);
-
-    // Create and configure function
-    NENormalizationLayer norm;
-    norm.configure(&src, &dst, norm_info);
-
-    // Allocate tensors
-    src.allocator()->allocate();
-    dst.allocator()->allocate();
-
-    BOOST_TEST(!src.info()->is_resizable());
-    BOOST_TEST(!dst.info()->is_resizable());
-
-    // Fill tensors
-    if(dt == DataType::QS8)
-    {
-        const int8_t one_fixed_point       = 1 << fixed_point_position;
-        const int8_t minus_one_fixed_point = -one_fixed_point;
-        library->fill_tensor_uniform(Accessor(src), 0, minus_one_fixed_point, one_fixed_point);
-    }
-    else
-    {
-        library->fill_tensor_uniform(Accessor(src), 0);
-    }
-
-    // Compute function
-    norm.run();
-
-    return dst;
-}
-} // namespace
-
-#ifndef DOXYGEN_SKIP_THIS
-BOOST_AUTO_TEST_SUITE(NEON)
-BOOST_AUTO_TEST_SUITE(NormalizationLayer)
-
-#ifdef ARM_COMPUTE_ENABLE_FP16
-BOOST_AUTO_TEST_SUITE(Float16)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall,
-                     SmallShapes() * DataType::F16 *NormalizationTypes() * boost::unit_test::data::xrange(3, 9, 2) * boost::unit_test::data::make({ 0.5f, 1.0f, 2.0f }),
-                     shape, dt, norm_type, norm_size, beta)
-{
-    // Provide normalization layer information
-    NormalizationLayerInfo norm_info(norm_type, norm_size, 5, beta);
-
-    // Compute function
-    Tensor dst = compute_normalization_layer(shape, dt, norm_info);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_normalization_layer(shape, dt, norm_info);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, normalization_layer_tolerance(DataType::F16));
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* ARM_COMPUTE_ENABLE_FP16 */
-
-BOOST_AUTO_TEST_SUITE(Float)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall,
-                     SmallShapes() * DataType::F32 *NormalizationTypes() * boost::unit_test::data::xrange(3, 9, 2) * boost::unit_test::data::make({ 0.5f, 1.0f, 2.0f }),
-                     shape, dt, norm_type, norm_size, beta)
-{
-    // Provide normalization layer information
-    NormalizationLayerInfo norm_info(norm_type, norm_size, 5, beta);
-
-    // Compute function
-    Tensor dst = compute_normalization_layer(shape, dt, norm_info);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_normalization_layer(shape, dt, norm_info);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, normalization_layer_tolerance(DataType::F32));
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE(Quantized)
-BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
-BOOST_DATA_TEST_CASE(RunSmall,
-                     SmallShapes() * DataType::QS8 *NormalizationTypes() * boost::unit_test::data::xrange(3, 7, 2) * (boost::unit_test::data::xrange(1, 6) * boost::unit_test::data::make({ 0.5f, 1.0f, 2.0f })),
-                     shape, dt, norm_type, norm_size, fixed_point_position, beta)
-{
-    // Provide normalization layer information
-    NormalizationLayerInfo norm_info(norm_type, norm_size, 5, beta, 1.f);
-
-    // Compute function
-    Tensor dst = compute_normalization_layer(shape, dt, norm_info, fixed_point_position);
-
-    // Compute reference
-    RawTensor ref_dst = Reference::compute_reference_normalization_layer(shape, dt, norm_info, fixed_point_position);
-
-    // Validate output
-    validate(Accessor(dst), ref_dst, normalization_layer_tolerance(DataType::QS8));
-}
-BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_AUTO_TEST_SUITE_END()
-BOOST_AUTO_TEST_SUITE_END()
-#endif /* DOXYGEN_SKIP_THIS */
diff --git a/tests/validation/Reference.cpp b/tests/validation/Reference.cpp
index 5c669903c8..b7553f3b7b 100644
--- a/tests/validation/Reference.cpp
+++ b/tests/validation/Reference.cpp
@@ -660,30 +660,6 @@ RawTensor Reference::compute_reference_fully_connected_layer(const TensorShape &
     return ref_dst;
 }
 
-RawTensor Reference::compute_reference_normalization_layer(const TensorShape &shape, DataType dt, NormalizationLayerInfo norm_info, int fixed_point_position)
-{
-    // Create reference
-    RawTensor ref_src(shape, dt, 1, fixed_point_position);
-    RawTensor ref_dst(shape, dt, 1, fixed_point_position);
-
-    // Fill reference
-    if(dt == DataType::QS8)
-    {
-        const int8_t one_fixed_point       = 1 << fixed_point_position;
-        const int8_t minus_one_fixed_point = -one_fixed_point;
-        library->fill_tensor_uniform(ref_src, 0, minus_one_fixed_point, one_fixed_point);
-    }
-    else
-    {
-        library->fill_tensor_uniform(ref_src, 0);
-    }
-
-    // Compute reference
-    ReferenceCPP::normalization_layer(ref_src, ref_dst, norm_info);
-
-    return ref_dst;
-}
-
 RawTensor Reference::compute_reference_pooling_layer(const TensorShape &shape_in, const TensorShape &shape_out, DataType dt, PoolingLayerInfo pool_info, int fixed_point_position)
 {
     // Create reference
diff --git a/tests/validation/Reference.h b/tests/validation/Reference.h
index 034a308327..778e7b0b2b 100644
--- a/tests/validation/Reference.h
+++ b/tests/validation/Reference.h
@@ -353,16 +353,6 @@ public:
      */
     static RawTensor compute_reference_fully_connected_layer(const TensorShape &input_shape, const TensorShape &weights_shape, const TensorShape &bias_shape, const TensorShape &output_shape, DataType dt,
                                                              bool transpose_weights, int fixed_point_position);
-    /** Compute reference normalization layer.
-     *
-     * @param[in] shape                Shape of the input and output tensors.
-     * @param[in] dt                   Data type of input and output tensors.
-     * @param[in] norm_info            Normalization Layer information.
-     * @param[in] fixed_point_position (Optional) Fixed point position that expresses the number of bits for the fractional part of the number when the tensor's data type is QS8 or QS16 (default = 0).
-     *
-     * @return Computed raw tensor.
-     */
-    static RawTensor compute_reference_normalization_layer(const TensorShape &shape, DataType dt, NormalizationLayerInfo norm_info, int fixed_point_position = 0);
     /** Compute reference pooling layer.
       *
       * @param[in] shape_in             Shape of the input tensor.
diff --git a/tests/validation/ReferenceCPP.cpp b/tests/validation/ReferenceCPP.cpp
index dd2437195e..13f4b90a82 100644
--- a/tests/validation/ReferenceCPP.cpp
+++ b/tests/validation/ReferenceCPP.cpp
@@ -337,14 +337,6 @@ void ReferenceCPP::fully_connected_layer(const RawTensor &src, const RawTensor &
     boost::apply_visitor(tensor_visitors::fully_connected_layer_visitor(s, w, b), d);
 }
 
-// Normalization Layer
-void ReferenceCPP::normalization_layer(const RawTensor &src, RawTensor &dst, NormalizationLayerInfo norm_info)
-{
-    const TensorVariant s = TensorFactory::get_tensor(src);
-    TensorVariant       d = TensorFactory::get_tensor(dst);
-    boost::apply_visitor(tensor_visitors::normalization_layer_visitor(s, norm_info), d);
-}
-
 // Pooling Layer
 void ReferenceCPP::pooling_layer(const RawTensor &src, RawTensor &dst, PoolingLayerInfo pool_info, int fixed_point_position)
 {
diff --git a/tests/validation/ReferenceCPP.h b/tests/validation/ReferenceCPP.h
index 6d4d243c95..3f5e4aeaf5 100644
--- a/tests/validation/ReferenceCPP.h
+++ b/tests/validation/ReferenceCPP.h
@@ -296,13 +296,6 @@ public:
      * @param[out] dst     Result tensor.
      */
     static void fully_connected_layer(const RawTensor &src, const RawTensor &weights, const RawTensor &bias, RawTensor &dst);
-    /** Normalization of @p src based on the information from @p norm_info.
-     *
-     * @param[in]  src       Input tensor.
-     * @param[out] dst       Result tensor.
-     * @param[in]  norm_info Normalization Layer information.
-     */
-    static void normalization_layer(const RawTensor &src, RawTensor &dst, NormalizationLayerInfo norm_info);
     /** Pooling layer of @p src based on the information from @p pool_info.
      *
      * @param[in]  src                  Input tensor.
diff --git a/tests/validation/TensorOperations.h b/tests/validation/TensorOperations.h
index 5018bfdb2b..a5039a4641 100644
--- a/tests/validation/TensorOperations.h
+++ b/tests/validation/TensorOperations.h
@@ -1207,208 +1207,6 @@ void fully_connected_layer(const Tensor<T> &in, const Tensor<T> &weights, const
     }
 }
 
-// Normalization Layer for floating point type
-template <typename T, typename std::enable_if<is_floating_point<T>::value, int>::type * = nullptr>
-void normalization_layer(const Tensor<T> &in, Tensor<T> &out, NormalizationLayerInfo norm_info)
-{
-    const uint32_t norm_size = norm_info.norm_size();
-    NormType       type      = norm_info.type();
-    float          beta      = norm_info.beta();
-    uint32_t       kappa     = norm_info.kappa();
-
-    const int cols       = static_cast<int>(in.shape()[0]);
-    const int rows       = static_cast<int>(in.shape()[1]);
-    const int depth      = static_cast<int>(in.shape()[2]);
-    int       upper_dims = in.shape().total_size() / (cols * rows);
-
-    float coeff       = norm_info.scale_coeff();
-    int   radius_cols = norm_size / 2;
-    // IN_MAP_1D and CROSS_MAP normalize over a single axis only
-    int radius_rows = (NormType::IN_MAP_2D == type) ? norm_size / 2 : 0;
-
-    if(type == NormType::CROSS_MAP)
-    {
-        // Remove also depth from upper dimensions since it is the axes we want
-        // to use for normalization
-        upper_dims /= depth;
-        for(int r = 0; r < upper_dims; ++r)
-        {
-            for(int i = 0; i < rows; ++i)
-            {
-                for(int k = 0; k < cols; ++k)
-                {
-                    for(int l = 0; l < depth; ++l)
-                    {
-                        float accumulated_scale = 0.f;
-                        for(int j = -radius_cols; j <= radius_cols; ++j)
-                        {
-                            const int z = l + j;
-                            if(z >= 0 && z < depth)
-                            {
-                                const T value = in[k + i * cols + z * rows * cols + r * cols * rows * depth];
-                                accumulated_scale += value * value;
-                            }
-                        }
-                        out[k + i * cols + l * rows * cols + r * cols * rows * depth] = kappa + accumulated_scale * coeff;
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        for(int r = 0; r < upper_dims; ++r)
-        {
-            for(int i = 0; i < rows; ++i)
-            {
-                for(int k = 0; k < cols; ++k)
-                {
-                    float accumulated_scale = 0.f;
-                    for(int j = -radius_rows; j <= radius_rows; ++j)
-                    {
-                        const int y = i + j;
-                        for(int l = -radius_cols; l <= radius_cols; ++l)
-                        {
-                            const int x = k + l;
-                            if((x >= 0 && y >= 0) && (x < cols && y < rows))
-                            {
-                                const T value = in[x + y * cols + r * cols * rows];
-                                accumulated_scale += value * value;
-                            }
-                        }
-                    }
-                    out[k + i * cols + r * cols * rows] = kappa + accumulated_scale * coeff;
-                }
-            }
-        }
-    }
-
-    if(beta == 1.f)
-    {
-        for(int i = 0; i < out.num_elements(); ++i)
-        {
-            out[i] = in[i] / out[i];
-        }
-    }
-    else if(beta == 0.5f)
-    {
-        for(int i = 0; i < out.num_elements(); ++i)
-        {
-            out[i] = in[i] / std::sqrt(out[i]);
-        }
-    }
-    else
-    {
-        for(int i = 0; i < out.num_elements(); ++i)
-        {
-            out[i] = in[i] * std::exp(std::log(out[i]) * -beta);
-        }
-    }
-}
-// Normalization Layer for fixed-point types
-template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type * = nullptr>
-void normalization_layer(const Tensor<T> &in, Tensor<T> &out, NormalizationLayerInfo norm_info)
-{
-    using namespace fixed_point_arithmetic;
-
-    const int fixed_point_position = in.fixed_point_position();
-
-    const uint32_t norm_size = norm_info.norm_size();
-    NormType       type      = norm_info.type();
-    fixed_point<T> beta(norm_info.beta(), fixed_point_position);
-    fixed_point<T> kappa(norm_info.kappa(), fixed_point_position);
-
-    const int cols       = static_cast<int>(in.shape()[0]);
-    const int rows       = static_cast<int>(in.shape()[1]);
-    const int depth      = static_cast<int>(in.shape()[2]);
-    int       upper_dims = in.shape().total_size() / (cols * rows);
-
-    fixed_point<T> coeff(norm_info.scale_coeff(), fixed_point_position);
-    int            radius_cols = norm_size / 2;
-    // IN_MAP_1D and CROSS_MAP normalize over a single axis only
-    int radius_rows = (NormType::IN_MAP_2D == type) ? norm_size / 2 : 0;
-
-    if(type == NormType::CROSS_MAP)
-    {
-        // Remove also depth from upper dimensions since it is the axes we want
-        // to use for normalization
-        upper_dims /= depth;
-        for(int r = 0; r < upper_dims; ++r)
-        {
-            for(int i = 0; i < rows; ++i)
-            {
-                for(int k = 0; k < cols; ++k)
-                {
-                    for(int l = 0; l < depth; ++l)
-                    {
-                        fixed_point<T> accumulated_scale(0.f, fixed_point_position);
-                        for(int j = -radius_cols; j <= radius_cols; ++j)
-                        {
-                            const int z = l + j;
-                            if(z >= 0 && z < depth)
-                            {
-                                const T              value = in[k + i * cols + z * rows * cols + r * cols * rows * depth];
-                                const fixed_point<T> fp_value(value, fixed_point_position, true);
-                                accumulated_scale = add(accumulated_scale, mul(fp_value, fp_value));
-                            }
-                        }
-                        accumulated_scale                                             = add(kappa, mul(accumulated_scale, coeff));
-                        out[k + i * cols + l * rows * cols + r * cols * rows * depth] = accumulated_scale.raw();
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        for(int r = 0; r < upper_dims; ++r)
-        {
-            for(int i = 0; i < rows; ++i)
-            {
-                for(int k = 0; k < cols; ++k)
-                {
-                    fixed_point<T> accumulated_scale(0.f, fixed_point_position);
-                    for(int j = -radius_rows; j <= radius_rows; ++j)
-                    {
-                        const int y = i + j;
-                        for(int l = -radius_cols; l <= radius_cols; ++l)
-                        {
-                            const int x = k + l;
-                            if((x >= 0 && y >= 0) && (x < cols && y < rows))
-                            {
-                                const T              value = in[x + y * cols + r * cols * rows];
-                                const fixed_point<T> fp_value(value, fixed_point_position, true);
-                                accumulated_scale = add(accumulated_scale, mul(fp_value, fp_value));
-                            }
-                        }
-                    }
-                    accumulated_scale                   = add(kappa, mul(accumulated_scale, coeff));
-                    out[k + i * cols + r * cols * rows] = accumulated_scale.raw();
-                }
-            }
-        }
-    }
-
-    if(norm_info.beta() == 1.f)
-    {
-        for(int i = 0; i < out.num_elements(); ++i)
-        {
-            fixed_point<T> res = div(fixed_point<T>(in[i], fixed_point_position, true), fixed_point<T>(out[i], fixed_point_position, true));
-            out[i]             = res.raw();
-        }
-    }
-    else
-    {
-        const fixed_point<T> beta(norm_info.beta(), fixed_point_position);
-        for(int i = 0; i < out.num_elements(); ++i)
-        {
-            fixed_point<T> res = pow(fixed_point<T>(out[i], fixed_point_position, true), beta);
-            res                = div(fixed_point<T>(in[i], fixed_point_position, true), res);
-            out[i]             = res.raw();
-        }
-    }
-}
-
 // Pooling layer
 template <typename T>
 void pooling_layer(const Tensor<T> &in, Tensor<T> &out, PoolingLayerInfo pool_info, int fixed_point_position)
diff --git a/tests/validation/TensorVisitors.h b/tests/validation/TensorVisitors.h
index bccb70a1d3..fa9c3ecbb8 100644
--- a/tests/validation/TensorVisitors.h
+++ b/tests/validation/TensorVisitors.h
@@ -345,26 +345,6 @@ private:
     const TensorVariant &_bias;
 };
 
-// Normalization Layer visitor
-struct normalization_layer_visitor : public boost::static_visitor<>
-{
-public:
-    explicit normalization_layer_visitor(const TensorVariant &in, NormalizationLayerInfo norm_info)
-        : _in(in), _norm_info(norm_info)
-    {
-    }
-
-    template <typename T>
-    void operator()(Tensor<T> &out) const
-    {
-        const Tensor<T> &in = boost::get<Tensor<T>>(_in);
-        tensor_operations::normalization_layer(in, out, _norm_info);
-    }
-
-private:
-    const TensorVariant   &_in;
-    NormalizationLayerInfo _norm_info;
-};
 // Pooling layer
 struct pooling_layer_visitor : public boost::static_visitor<>
 {