COMPMID-424 NEON MinMaxLocation test.
Change-Id: I3dda0961061b52c680b5af0443ad93a00425dd4c
Reviewed-on: http://mpd-gerrit.cambridge.arm.com/77433
Reviewed-by: Michele DiGiorgio <michele.digiorgio@arm.com>
Tested-by: Kaizen <jeremy.johnson+kaizengerrit@arm.com>
Reviewed-by: Steven Niu <steven.niu@arm.com>
diff --git a/tests/validation/NEON/CMakeLists.txt b/tests/validation/NEON/CMakeLists.txt
index 4e15b8e..ba35249 100644
--- a/tests/validation/NEON/CMakeLists.txt
+++ b/tests/validation/NEON/CMakeLists.txt
@@ -22,6 +22,7 @@
cmake_minimum_required (VERSION 3.1)
set(arm_compute_test_validation_NEON_SOURCE_FILES
+ ${CMAKE_SOURCE_DIR}/NEON/Helper.h
${CMAKE_SOURCE_DIR}/NEON/NEAccessor.h
${CMAKE_CURRENT_SOURCE_DIR}/AbsoluteDifference.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Accumulate.cpp
@@ -45,17 +46,17 @@
${CMAKE_CURRENT_SOURCE_DIR}/Fixedpoint/Reciprocal_QS8.cpp
${CMAKE_CURRENT_SOURCE_DIR}/FullyConnectedLayer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Gaussian3x3.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Gaussian5x5.cpp
${CMAKE_CURRENT_SOURCE_DIR}/GEMM.cpp
${CMAKE_CURRENT_SOURCE_DIR}/IntegralImage.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/MeanStdDev.cpp
${CMAKE_CURRENT_SOURCE_DIR}/NormalizationLayer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/PixelWiseMultiplication.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/MeanStdDev.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Pooling/PoolingLayer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Sobel3x3.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Sobel5x5.cpp
${CMAKE_CURRENT_SOURCE_DIR}/SoftmaxLayer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/Threshold.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/MinMaxLocation.cpp
)
add_library(arm_compute_test_validation_NEON OBJECT
diff --git a/tests/validation/NEON/MinMaxLocation.cpp b/tests/validation/NEON/MinMaxLocation.cpp
new file mode 100644
index 0000000..bbb4589
--- /dev/null
+++ b/tests/validation/NEON/MinMaxLocation.cpp
@@ -0,0 +1,192 @@
+/*
+ * 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 "Globals.h"
+#include "NEON/Helper.h"
+#include "NEON/NEAccessor.h"
+#include "PaddingCalculator.h"
+#include "TensorLibrary.h"
+#include "TypePrinter.h"
+#include "Utils.h"
+#include "validation/Datasets.h"
+#include "validation/Reference.h"
+#include "validation/Validation.h"
+
+#include "arm_compute/core/Helpers.h"
+#include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/NEON/functions/NEMinMaxLocation.h"
+#include "arm_compute/runtime/Tensor.h"
+#include "arm_compute/runtime/TensorAllocator.h"
+
+#include "boost_wrapper.h"
+
+#include <random>
+#include <string>
+
+using namespace arm_compute;
+using namespace arm_compute::test;
+using namespace arm_compute::test::neon;
+using namespace arm_compute::test::validation;
+
+namespace
+{
+/** Compute Neon MinMaxLocation function.
+ *
+ * @param[in] shape Shape of the input and output tensors.
+ * @param[in] dt_in Data type of first input tensor.
+ * @param[out] min Minimum value of tensor
+ * @param[out] max Maximum value of tensor
+ * @param[out] min_loc Array with locations of minimum values
+ * @param[out] max_loc Array with locations of maximum values
+ * @param[out] min_count Number of minimum values found
+ * @param[out] max_count Number of maximum values found
+ *
+ * @return Computed output tensor.
+ */
+
+void compute_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max,
+ Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+ // Create tensor
+ Tensor src = create_tensor<Tensor>(shape, dt_in);
+ src.info()->set_format((dt_in == DataType::U8) ? Format::U8 : Format::S16);
+
+ // Create and configure min_max_location configure function
+ NEMinMaxLocation min_max_loc;
+ min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
+
+ // Allocate tensors
+ src.allocator()->allocate();
+
+ BOOST_TEST(!src.info()->is_resizable());
+
+ // Fill tensors
+ library->fill_tensor_uniform(NEAccessor(src), 0);
+
+ // Compute function
+ min_max_loc.run();
+}
+
+void validate_configuration(const Tensor &src, TensorShape shape)
+{
+ BOOST_TEST(src.info()->is_resizable());
+
+ // Create output storage
+ int32_t min;
+ int32_t max;
+ Coordinates2DArray min_loc;
+ Coordinates2DArray max_loc;
+ uint32_t min_count;
+ uint32_t max_count;
+
+ // Create and configure function
+ NEMinMaxLocation min_max_loc;
+ min_max_loc.configure(&src, &min, &max, &min_loc, &max_loc, &min_count, &max_count);
+
+ // Validate valid region
+ const ValidRegion valid_region = shape_to_valid_region(shape);
+ validate(src.info()->valid_region(), valid_region);
+
+ // Validate padding
+ const PaddingSize padding = PaddingCalculator(shape.x(), 1).required_padding();
+ validate(src.info()->padding(), padding);
+}
+} // namespace
+
+#ifndef DOXYGEN_SKIP_THIS
+BOOST_AUTO_TEST_SUITE(NEON)
+BOOST_AUTO_TEST_SUITE(MinMaxLocation)
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit") * boost::unit_test::label("nightly"))
+BOOST_DATA_TEST_CASE(Configuration, (Small2DShapes() + Large2DShapes()) * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+ shape, dt)
+{
+ // Create tensor
+ Tensor src = create_tensor<Tensor>(shape, dt);
+ src.info()->set_format(dt == DataType::U8 ? Format::U8 : Format::S16);
+
+ validate_configuration(src, shape);
+}
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("precommit"))
+BOOST_DATA_TEST_CASE(RunSmall, Small2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+ shape, dt)
+{
+ // Create output storage
+ int32_t min;
+ int32_t max;
+ Coordinates2DArray min_loc(shape.total_size());
+ Coordinates2DArray max_loc(shape.total_size());
+ uint32_t min_count;
+ uint32_t max_count;
+
+ int32_t ref_min;
+ int32_t ref_max;
+ Coordinates2DArray ref_min_loc(shape.total_size());
+ Coordinates2DArray ref_max_loc(shape.total_size());
+ uint32_t ref_min_count;
+ uint32_t ref_max_count;
+
+ // Compute function
+ compute_min_max_location(shape, dt, min, max, min_loc, max_loc, min_count, max_count);
+
+ // Compute reference
+ Reference::compute_reference_min_max_location(shape, dt, ref_min, ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
+
+ // Validate output
+ validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
+}
+
+BOOST_TEST_DECORATOR(*boost::unit_test::label("nightly"))
+BOOST_DATA_TEST_CASE(RunLarge, Large2DShapes() * boost::unit_test::data::make({ DataType::U8, DataType::S16 }),
+ shape, dt)
+{
+ // Create output storage
+ int32_t min;
+ int32_t max;
+ Coordinates2DArray min_loc(shape.total_size());
+ Coordinates2DArray max_loc(shape.total_size());
+ uint32_t min_count;
+ uint32_t max_count;
+
+ int32_t ref_min;
+ int32_t ref_max;
+ Coordinates2DArray ref_min_loc(shape.total_size());
+ Coordinates2DArray ref_max_loc(shape.total_size());
+ uint32_t ref_min_count;
+ uint32_t ref_max_count;
+
+ // Compute function
+ compute_min_max_location(shape, dt, min, max, min_loc, max_loc, min_count, max_count);
+
+ // Compute reference
+ Reference::compute_reference_min_max_location(shape, dt, ref_min, ref_max, ref_min_loc, ref_max_loc, ref_min_count, ref_max_count);
+
+ // Validate output
+ validate_min_max_loc(min, ref_min, max, ref_max, min_loc, ref_min_loc, max_loc, ref_max_loc, min_count, ref_min_count, max_count, ref_max_count);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+#endif /* DOXYGEN_SKIP_THIS */
\ No newline at end of file
diff --git a/tests/validation/Reference.cpp b/tests/validation/Reference.cpp
index 4b4919f..3b429c1 100644
--- a/tests/validation/Reference.cpp
+++ b/tests/validation/Reference.cpp
@@ -71,6 +71,18 @@
return std::make_pair(ref_dst_x, ref_dst_y);
}
+void Reference::compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc,
+ uint32_t &min_count, uint32_t &max_count)
+{
+ // Create reference
+ RawTensor ref_src = library->get(shape, dt_in);
+
+ // Fill reference
+ library->fill_tensor_uniform(ref_src, 0);
+
+ // Compute reference
+ ReferenceCPP::min_max_location(ref_src, min, max, min_loc, max_loc, min_count, max_count);
+}
std::pair<float, float> Reference::compute_reference_mean_and_standard_deviation(const TensorShape &shape)
{
// Create reference
diff --git a/tests/validation/Reference.h b/tests/validation/Reference.h
index a3ae3b6..259afd1 100644
--- a/tests/validation/Reference.h
+++ b/tests/validation/Reference.h
@@ -26,6 +26,7 @@
#include "RawTensor.h"
#include "Types.h"
+#include "arm_compute/runtime/Array.h"
#include <map>
#include <vector>
@@ -58,6 +59,21 @@
* @return Computed raw tensors along x and y axis.
*/
static std::pair<RawTensor, RawTensor> compute_reference_sobel_5x5(const TensorShape &shape, BorderMode border_mode, uint8_t constant_border_value);
+ /** Compute min max location.
+ *
+ * @param[in] shape Shape of the input tensors.
+ * @param[in] dt_in Data type of input tensor.
+ * @param[out] min Minimum value of tensor
+ * @param[out] max Maximum value of tensor
+ * @param[out] min_loc Array with locations of minimum values
+ * @param[out] max_loc Array with locations of maximum values
+ * @param[out] min_count Number of minimum values found
+ * @param[out] max_count Number of maximum values found
+ *
+ * @return Computed minimum, maximum values and their locations.
+ */
+ static void compute_reference_min_max_location(const TensorShape &shape, DataType dt_in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count,
+ uint32_t &max_count);
/** Compute reference mean and standard deviation.
*
* @param[in] shape Shape of the input tensors.
diff --git a/tests/validation/ReferenceCPP.cpp b/tests/validation/ReferenceCPP.cpp
index 0db0352..a1dc4ce 100644
--- a/tests/validation/ReferenceCPP.cpp
+++ b/tests/validation/ReferenceCPP.cpp
@@ -70,6 +70,13 @@
tensor_operations::sobel_5x5(s, dx, dy, border_mode, constant_border_value);
}
+// Minimum maximum location
+void ReferenceCPP::min_max_location(const RawTensor &src, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+ const TensorVariant s = TensorFactory::get_tensor(src);
+ boost::apply_visitor(tensor_visitors::min_max_location_visitor(min, max, min_loc, max_loc, min_count, max_count), s);
+}
+
// Absolute difference
void ReferenceCPP::absolute_difference(const RawTensor &src1, const RawTensor &src2, RawTensor &dst)
{
diff --git a/tests/validation/ReferenceCPP.h b/tests/validation/ReferenceCPP.h
index 8a5d853..bc9ea47 100644
--- a/tests/validation/ReferenceCPP.h
+++ b/tests/validation/ReferenceCPP.h
@@ -64,6 +64,17 @@
*
*/
static void sobel_5x5(RawTensor &src, RawTensor &dst_x, RawTensor &dst_y, BorderMode border_mode, uint8_t constant_border_value);
+ /** Function to compute the min max values and their location in a tensor.
+ *
+ * @param[in] src Input tensor.
+ * @param[out] min Minimum value of the tensor.
+ * @param[out] max Maximum value of the tensor
+ * @param[out] min_loc Array with locations of minimum values
+ * @param[out] max_loc Array with locations of maximum values
+ * @param[out] min_count Number of minimum values found
+ * @param[out] max_count Number of maximum values found
+ */
+ static void min_max_location(const RawTensor &src, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count);
/** Function to compute the mean and standard deviation of a tensor.
*
* @param[in] src Input tensor.
diff --git a/tests/validation/TensorOperations.h b/tests/validation/TensorOperations.h
index 882c9e0..9e201e2 100644
--- a/tests/validation/TensorOperations.h
+++ b/tests/validation/TensorOperations.h
@@ -311,6 +311,56 @@
}
}
+// Min max location
+template <typename T1>
+void min_max_location(const Tensor<T1> &in, int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+{
+ // Set min and max to first pixel
+ min = in[0];
+ max = in[0];
+ min_count = 0;
+ max_count = 0;
+
+ const size_t width = in.shape().x();
+
+ // Look for min and max values
+ for(int i = 1; i < in.num_elements(); ++i)
+ {
+ if(static_cast<int32_t>(in[i]) < min)
+ {
+ min = in[i];
+ }
+ if(static_cast<int32_t>(in[i]) > max)
+ {
+ max = in[i];
+ }
+ }
+
+ for(int i = 0; i < in.num_elements(); ++i)
+ {
+ if(static_cast<int32_t>(in[i]) == min)
+ {
+ Coordinates2D min_coord;
+ min_coord.x = static_cast<int32_t>(i % width);
+ min_coord.y = static_cast<int32_t>(i / width);
+
+ min_loc.push_back(min_coord);
+
+ min_count++;
+ }
+ if(static_cast<int32_t>(in[i]) == max)
+ {
+ Coordinates2D max_coord;
+ max_coord.x = static_cast<int32_t>(i % width);
+ max_coord.y = static_cast<int32_t>(i / width);
+
+ max_loc.push_back(max_coord);
+
+ max_count++;
+ }
+ }
+}
+
// Mean Standard Deviation
template <typename T1>
void mean_and_standard_deviation(const Tensor<T1> &in, float &mean, float &std_dev)
diff --git a/tests/validation/TensorVisitors.h b/tests/validation/TensorVisitors.h
index c58b9a6..168e212 100644
--- a/tests/validation/TensorVisitors.h
+++ b/tests/validation/TensorVisitors.h
@@ -45,6 +45,28 @@
{
namespace tensor_visitors
{
+// Min max location visitor
+struct min_max_location_visitor : public boost::static_visitor<>
+{
+public:
+ explicit min_max_location_visitor(int32_t &min, int32_t &max, Coordinates2DArray &min_loc, Coordinates2DArray &max_loc, uint32_t &min_count, uint32_t &max_count)
+ : _min(min), _max(max), _min_loc(min_loc), _max_loc(max_loc), _min_count(min_count), _max_count(max_count)
+ {
+ }
+ template <typename T1>
+ void operator()(const Tensor<T1> &in) const
+ {
+ tensor_operations::min_max_location(in, _min, _max, _min_loc, _max_loc, _min_count, _max_count);
+ }
+
+private:
+ int32_t &_min;
+ int32_t &_max;
+ Coordinates2DArray &_min_loc;
+ Coordinates2DArray &_max_loc;
+ uint32_t &_min_count;
+ uint32_t &_max_count;
+};
// Absolute Difference visitor
struct absolute_difference_visitor : public boost::static_visitor<>
{
diff --git a/tests/validation/Validation.cpp b/tests/validation/Validation.cpp
index f65f229..e949e3c 100644
--- a/tests/validation/Validation.cpp
+++ b/tests/validation/Validation.cpp
@@ -410,6 +410,34 @@
BOOST_TEST(equal);
}
+void validate_min_max_loc(int32_t min, int32_t ref_min, int32_t max, int32_t ref_max,
+ Coordinates2DArray &min_loc, Coordinates2DArray &ref_min_loc, Coordinates2DArray &max_loc, Coordinates2DArray &ref_max_loc,
+ uint32_t min_count, uint32_t ref_min_count, uint32_t max_count, uint32_t ref_max_count)
+{
+ BOOST_TEST(min == ref_min);
+ BOOST_TEST(max == ref_max);
+
+ BOOST_TEST(min_count == min_loc.num_values());
+ BOOST_TEST(max_count == max_loc.num_values());
+ BOOST_TEST(ref_min_count == ref_min_loc.num_values());
+ BOOST_TEST(ref_max_count == ref_max_loc.num_values());
+
+ BOOST_TEST(min_count == ref_min_count);
+ BOOST_TEST(max_count == ref_max_count);
+
+ for(uint32_t i = 0; i < min_count; i++)
+ {
+ BOOST_TEST(min_loc.at(i).x == ref_min_loc.at(i).x);
+ BOOST_TEST(min_loc.at(i).y == ref_min_loc.at(i).y);
+ }
+
+ for(uint32_t i = 0; i < max_count; i++)
+ {
+ BOOST_TEST(max_loc.at(i).x == ref_max_loc.at(i).x);
+ BOOST_TEST(max_loc.at(i).y == ref_max_loc.at(i).y);
+ }
+}
+
} // namespace validation
} // namespace test
} // namespace arm_compute
diff --git a/tests/validation/Validation.h b/tests/validation/Validation.h
index e833ae4..e254c9f 100644
--- a/tests/validation/Validation.h
+++ b/tests/validation/Validation.h
@@ -25,6 +25,7 @@
#define __ARM_COMPUTE_TEST_REFERENCE_VALIDATION_H__
#include "arm_compute/core/Types.h"
+#include "arm_compute/runtime/Array.h"
#include "boost_wrapper.h"
@@ -128,6 +129,14 @@
*/
void validate(float target, float ref, float tolerance_abs_error = std::numeric_limits<float>::epsilon(), float tolerance_relative_error = 0.0001f);
+/** Validate min max location.
+ *
+ * - All values should match
+ */
+void validate_min_max_loc(int32_t min, int32_t ref_min, int32_t max, int32_t ref_max,
+ Coordinates2DArray &min_loc, Coordinates2DArray &ref_min_loc, Coordinates2DArray &max_loc, Coordinates2DArray &ref_max_loc,
+ uint32_t min_count, uint32_t ref_min_count, uint32_t max_count, uint32_t ref_max_count);
+
} // namespace validation
} // namespace test
} // namespace arm_compute