From a09de0c8b2ed0f1481502d3b023375609362d9e3 Mon Sep 17 00:00:00 2001 From: Moritz Pflanzer Date: Fri, 1 Sep 2017 20:41:12 +0100 Subject: COMPMID-415: Rename and move tests The boost validation is now "standalone" in validation_old and builds as arm_compute_validation_old. The new validation builds now as arm_compute_validation. Change-Id: Ib93ba848a25680ac60afb92b461d574a0757150d Reviewed-on: http://mpd-gerrit.cambridge.arm.com/86187 Tested-by: Kaizen Reviewed-by: Anthony Barbier --- tests/validation/Helpers.h | 259 +++++++++++---------------------------------- 1 file changed, 64 insertions(+), 195 deletions(-) (limited to 'tests/validation/Helpers.h') diff --git a/tests/validation/Helpers.h b/tests/validation/Helpers.h index 19a0c4105c..30959161bb 100644 --- a/tests/validation/Helpers.h +++ b/tests/validation/Helpers.h @@ -25,18 +25,12 @@ #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 "arm_compute/core/Utils.h" #include "tests/validation/half.h" -#include -#include #include #include #include -#include namespace arm_compute { @@ -44,158 +38,95 @@ 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 -void fill_tensors(D &&dist, std::initializer_list seeds, T &&tensor, Ts &&... other_tensors) +template +struct is_floating_point : public std::is_floating_point { - const std::array < T, 1 + sizeof...(Ts) > tensors{ { std::forward(tensor), std::forward(other_tensors)... } }; - std::vector vs(seeds); - ARM_COMPUTE_ERROR_ON(vs.size() != tensors.size()); - int k = 0; - for(auto tp : tensors) - { - library->fill(*tp, std::forward(dist), vs[k++]); - } -} +}; + +template <> +struct is_floating_point : public std::true_type +{ +}; /** Helper function to get the testing range for each activation layer. * * @param[in] activation Activation function to test. - * @param[in] fixed_point_position (Optional) Number of bits for the fractional part. Defaults to 1. + * @param[in] data_type Data type. + * @param[in] fixed_point_position Number of bits for the fractional part. Defaults to 1. * * @return A pair containing the lower upper testing bounds for a given function. */ template -inline std::pair get_activation_layer_test_bounds(ActivationLayerInfo::ActivationFunction activation, int fixed_point_position = 1) +std::pair get_activation_layer_test_bounds(ActivationLayerInfo::ActivationFunction activation, DataType data_type, int fixed_point_position = 0) { - bool is_float = std::is_same::value; - is_float = is_float || std::is_same::value; - std::pair bounds; - // Set initial values - if(is_float) - { - bounds = std::make_pair(-255.f, 255.f); - } - else + switch(data_type) { - bounds = std::make_pair(std::numeric_limits::lowest(), std::numeric_limits::max()); - } + case DataType::F16: + { + using namespace half_float::literal; - // Reduce testing ranges - switch(activation) - { - case ActivationLayerInfo::ActivationFunction::LOGISTIC: - case ActivationLayerInfo::ActivationFunction::SOFT_RELU: - // Reduce range as exponent overflows - if(is_float) + switch(activation) { - bounds.first = -40.f; - bounds.second = 40.f; - } - else - { - bounds.first = -(1 << (fixed_point_position)); - bounds.second = 1 << (fixed_point_position); + case ActivationLayerInfo::ActivationFunction::SQUARE: + case ActivationLayerInfo::ActivationFunction::LOGISTIC: + case ActivationLayerInfo::ActivationFunction::SOFT_RELU: + // Reduce range as exponent overflows + bounds = std::make_pair(-10._h, 10._h); + break; + case ActivationLayerInfo::ActivationFunction::SQRT: + // Reduce range as sqrt should take a non-negative number + bounds = std::make_pair(0._h, 255._h); + break; + default: + bounds = std::make_pair(-255._h, 255._h); + break; } break; - case ActivationLayerInfo::ActivationFunction::TANH: - // Reduce range as exponent overflows - if(!is_float) + } + case DataType::F32: + switch(activation) { - bounds.first = -(1 << (fixed_point_position)); - bounds.second = 1 << (fixed_point_position); + case ActivationLayerInfo::ActivationFunction::LOGISTIC: + case ActivationLayerInfo::ActivationFunction::SOFT_RELU: + // Reduce range as exponent overflows + bounds = std::make_pair(-40.f, 40.f); + break; + case ActivationLayerInfo::ActivationFunction::SQRT: + // Reduce range as sqrt should take a non-negative number + bounds = std::make_pair(0.f, 255.f); + break; + default: + bounds = std::make_pair(-255.f, 255.f); + break; } break; - case ActivationLayerInfo::ActivationFunction::SQRT: - // Reduce range as sqrt should take a non-negative number - bounds.first = (is_float) ? 0 : 1; - break; - default: - break; - } - return bounds; -} -/** Helper function to get the testing range for batch normalization layer. - * - * @param[in] fixed_point_position (Optional) Number of bits for the fractional part. Defaults to 1. - * - * @return A pair containing the lower upper testing bounds. - */ -template -std::pair get_batchnormalization_layer_test_bounds(int fixed_point_position = 1) -{ - bool is_float = std::is_floating_point::value; - std::pair bounds; - - // Set initial values - if(is_float) - { - bounds = std::make_pair(-1.f, 1.f); - } - else - { - bounds = std::make_pair(1, 1 << (fixed_point_position)); - } - - return bounds; -} - -/** Fill mask with the corresponding given pattern. - * - * @param[in,out] mask Mask to be filled according to pattern - * @param[in] cols Columns (width) of mask - * @param[in] rows Rows (height) of mask - * @param[in] pattern Pattern to fill the mask according to - */ -inline void fill_mask_from_pattern(uint8_t *mask, int cols, int rows, MatrixPattern pattern) -{ - unsigned int v = 0; - std::mt19937 gen(user_config.seed.get()); - std::bernoulli_distribution dist(0.5); - - for(int r = 0; r < rows; ++r) - { - for(int c = 0; c < cols; ++c, ++v) - { - uint8_t val = 0; - - switch(pattern) + case DataType::QS8: + case DataType::QS16: + switch(activation) { - case MatrixPattern::BOX: - val = 255; - break; - case MatrixPattern::CROSS: - val = ((r == (rows / 2)) || (c == (cols / 2))) ? 255 : 0; - break; - case MatrixPattern::DISK: - val = (((r - rows / 2.0f + 0.5f) * (r - rows / 2.0f + 0.5f)) / ((rows / 2.0f) * (rows / 2.0f)) + ((c - cols / 2.0f + 0.5f) * (c - cols / 2.0f + 0.5f)) / ((cols / 2.0f) * - (cols / 2.0f))) <= 1.0f ? 255 : 0; + case ActivationLayerInfo::ActivationFunction::LOGISTIC: + case ActivationLayerInfo::ActivationFunction::SOFT_RELU: + case ActivationLayerInfo::ActivationFunction::TANH: + // Reduce range as exponent overflows + bounds = std::make_pair(-(1 << fixed_point_position), 1 << fixed_point_position); break; - case MatrixPattern::OTHER: - val = (dist(gen) ? 0 : 255); + case ActivationLayerInfo::ActivationFunction::SQRT: + // Reduce range as sqrt should take a non-negative number + // Can't be zero either as inv_sqrt is used in NEON. + bounds = std::make_pair(1, std::numeric_limits::max()); break; default: - return; + bounds = std::make_pair(std::numeric_limits::lowest(), std::numeric_limits::max()); + break; } - - mask[v] = val; - } + break; + default: + ARM_COMPUTE_ERROR("Unsupported data type"); } - if(pattern == MatrixPattern::OTHER) - { - std::uniform_int_distribution distribution_u8(0, ((cols * rows) - 1)); - mask[distribution_u8(gen)] = 255; - } + return bounds; } /** Calculate output tensor shape give a vector of input tensor to concatenate @@ -204,69 +135,7 @@ inline void fill_mask_from_pattern(uint8_t *mask, int cols, int rows, MatrixPatt * * @return The shape of output concatenated tensor. */ -inline TensorShape calculate_depth_concatenate_shape(std::vector input_shapes) -{ - TensorShape out_shape = input_shapes.at(0); - - unsigned int max_x = 0; - unsigned int max_y = 0; - unsigned int depth = 0; - - for(auto const &shape : input_shapes) - { - max_x = std::max(shape.x(), max_x); - max_y = std::max(shape.y(), max_y); - depth += shape.z(); - } - - out_shape.set(0, max_x); - out_shape.set(1, max_y); - out_shape.set(2, depth); - - return out_shape; -} - -/** Fill matrix random. - * - * @param[in,out] matrix Matrix - * @param[in] cols Columns (width) of matrix - * @param[in] rows Rows (height) of matrix - */ -template -inline void fill_warp_matrix(std::array &matrix, int cols, int rows) -{ - std::mt19937 gen(user_config.seed.get()); - std::uniform_real_distribution dist(-1, 1); - - for(int v = 0, r = 0; r < rows; ++r) - { - for(int c = 0; c < cols; ++c, ++v) - { - matrix[v] = dist(gen); - } - } - if(SIZE == 9) - { - matrix[(cols * rows) - 1] = 1; - } -} - -/** Helper function to fill the Lut random by a ILutAccessor. - * - * @param[in,out] table Accessor at the Lut. - * - */ -template -void fill_lookuptable(T &&table) -{ - std::mt19937 generator(user_config.seed.get()); - std::uniform_int_distribution distribution(std::numeric_limits::min(), std::numeric_limits::max()); - - for(int i = std::numeric_limits::min(); i <= std::numeric_limits::max(); i++) - { - table[i] = distribution(generator); - } -} +TensorShape calculate_depth_concatenate_shape(const std::vector &input_shapes); } // namespace validation } // namespace test } // namespace arm_compute -- cgit v1.2.1