COMPMID-3364: improve the test suite for Scale on OpenCL
- change shapes to vector size-based shapes
- add ScaleValidationDataset header file to share datasets
between NEON and OpenCL
- more validate() tests on OpenCL
- remove redundant configuration tests
- (not scoped of this ticket) add validate() test for
sampling policy not supporting aligned corners to
NEON test suite
Change-Id: I889fd19261162c7454eff5389a67fdc9564dc1f3
Signed-off-by: Sang-Hoon Park <sang-hoon.park@arm.com>
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/3334
Tested-by: Arm Jenkins <bsgcomp@arm.com>
Reviewed-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
diff --git a/tests/validation/CL/Scale.cpp b/tests/validation/CL/Scale.cpp
index e7e481b..72b743e 100644
--- a/tests/validation/CL/Scale.cpp
+++ b/tests/validation/CL/Scale.cpp
@@ -28,12 +28,9 @@
#include "arm_compute/runtime/TensorAllocator.h"
#include "tests/CL/CLAccessor.h"
#include "tests/PaddingCalculator.h"
-#include "tests/datasets/BorderModeDataset.h"
-#include "tests/datasets/SamplingPolicyDataset.h"
-#include "tests/datasets/ShapeDatasets.h"
+#include "tests/datasets/ScaleValidationDataset.h"
#include "tests/framework/Asserts.h"
#include "tests/framework/Macros.h"
-#include "tests/framework/datasets/Datasets.h"
#include "tests/validation/Helpers.h"
#include "tests/validation/Validation.h"
#include "tests/validation/fixtures/ScaleFixture.h"
@@ -46,6 +43,23 @@
{
namespace
{
+using datasets::ScaleShapesBaseDataSet;
+using datasets::ScaleInterpolationPolicySet;
+using datasets::ScaleDataLayouts;
+using datasets::ScaleSamplingPolicySet;
+using datasets::ScaleAlignCornersSamplingPolicySet;
+
+/** We consider vector size in byte 16 since the maximum size of
+ * a vector used by @ref CLScaleKernel is currently 16-byte (float4).
+ */
+constexpr uint32_t vector_byte = 16;
+
+template <typename T>
+constexpr uint32_t num_elements_per_vector()
+{
+ return vector_byte / sizeof(T);
+}
+
/** CNN data types */
const auto ScaleDataTypes = framework::dataset::make("DataType",
{
@@ -55,16 +69,11 @@
DataType::F32,
});
-/** Sampling policy data set */
-const auto SamplingPolicySet = combine(datasets::SamplingPolicies(),
- framework::dataset::make("AlignCorners", { false }));
-
-/** Sampling policy data set for Aligned Corners which only allows TOP_LEFT poicy.*/
-const auto AlignCornersSamplingPolicySet = combine(framework::dataset::make("SamplingPolicy",
+/** Quantization information data set */
+const auto QuantizationInfoSet = framework::dataset::make("QuantizationInfo",
{
- SamplingPolicy::TOP_LEFT,
-}),
-framework::dataset::make("AlignCorners", { true }));
+ QuantizationInfo(0.5f, -1),
+});
/** Tolerance */
constexpr AbsoluteTolerance<uint8_t> tolerance_q8(1);
@@ -80,109 +89,150 @@
TEST_SUITE(CL)
TEST_SUITE(Scale)
+TEST_SUITE(Validate)
-// *INDENT-OFF*
-// clang-format off
+const auto default_input_shape = TensorShape{ 2, 3, 3, 2 };
+const auto default_output_shape = TensorShape{ 4, 6, 3, 2 };
-DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(
- framework::dataset::make("InputInfo",{ TensorInfo(TensorShape(28U, 32U, 2U), 1, DataType::F16),
- TensorInfo(TensorShape(28U, 32U, 2U), 1, DataType::F32),
- TensorInfo(TensorShape(36U, 36U, 2U, 4U), 1, DataType::U8),
- TensorInfo(TensorShape(40U, 35U, 2U, 4U), 1, DataType::S16),
- TensorInfo(TensorShape(37U, 37U, 2U), 1, DataType::F32), // window shrink
- TensorInfo(TensorShape(37U, 37U, 3U, 4U), 1, DataType::F32), // mismatching datatype
- TensorInfo(TensorShape(28U, 33U, 2U), 1, DataType::F32), // policy area, scale factor not correct
- }),
- framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 68U, 2U), 1, DataType::F16),
- TensorInfo(TensorShape(40U, 56U, 2U), 1, DataType::F32),
- TensorInfo(TensorShape(40U, 76U, 2U, 4U), 1, DataType::U8),
- TensorInfo(TensorShape(28U, 32U, 2U, 4U), 1, DataType::S16),
- TensorInfo(TensorShape(39U, 55U, 2U), 1, DataType::F32), // window shrink
- TensorInfo(TensorShape(39U, 77U, 3U, 4U), 1, DataType::F16), // mismatching datatype
- TensorInfo(TensorShape(26U, 21U, 2U), 1, DataType::F32), // policy area, scale factor not correct
- })),
- framework::dataset::make("Policy",{ InterpolationPolicy::BILINEAR,
- InterpolationPolicy::BILINEAR,
- InterpolationPolicy::NEAREST_NEIGHBOR,
- InterpolationPolicy::NEAREST_NEIGHBOR,
- InterpolationPolicy::NEAREST_NEIGHBOR,
- InterpolationPolicy::BILINEAR,
- InterpolationPolicy::AREA,
- })),
- framework::dataset::make("BorderMode",{ BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- BorderMode::UNDEFINED,
- })),
- framework::dataset::make("Expected", { true, true, true, true, false, false, false })),
-input_info, output_info, policy, border_mode, expected)
+constexpr auto default_data_type = DataType::U8;
+constexpr auto default_data_layout = DataLayout::NHWC;
+constexpr auto default_interpolation_policy = InterpolationPolicy::NEAREST_NEIGHBOR;
+constexpr auto default_border_mode = BorderMode::UNDEFINED;
+constexpr auto default_sampling_policy = SamplingPolicy::CENTER;
+constexpr bool default_use_padding = false;
+
+TEST_CASE(NullPtr, framework::DatasetMode::ALL)
{
- Status status = CLScale::validate(&input_info.clone()->set_is_resizable(false),
- &output_info.clone()->set_is_resizable(false), ScaleKernelInfo{policy, border_mode});
- ARM_COMPUTE_EXPECT(bool(status) == expected, framework::LogLevel::ERRORS);
+ const auto input = TensorInfo{ default_input_shape, 1, default_data_type, default_data_layout };
+ const auto output = TensorInfo{ default_output_shape, 1, default_data_type, default_data_layout };
+ Status result{};
+
+ // nullptr is given as input
+ result = CLScale::validate(nullptr, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+
+ // nullptr is given as output
+ result = CLScale::validate(&input, nullptr, ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
}
-// clang-format on
-// *INDENT-ON*
-
-DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::MediumShapes(), ScaleDataTypes),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- datasets::SamplingPolicies()),
- shape, data_type, policy, border_mode, sampling_policy)
+TEST_CASE(SupportDataType, framework::DatasetMode::ALL)
{
- std::mt19937 generator(library->seed());
- std::uniform_real_distribution<float> distribution_float(0.25, 2);
- const float scale_x = distribution_float(generator);
- const float scale_y = distribution_float(generator);
- std::uniform_int_distribution<uint8_t> distribution_u8(0, 255);
- uint8_t constant_border_value = distribution_u8(generator);
+ const std::map<DataType, bool> supported_data_types =
+ {
+ { DataType::U8, true },
+ { DataType::S8, false },
+ { DataType::QSYMM8, false },
+ { DataType::QASYMM8, true },
+ { DataType::QASYMM8_SIGNED, true },
+ { DataType::QSYMM8_PER_CHANNEL, false },
+ { DataType::U16, false },
+ { DataType::S16, true },
+ { DataType::QSYMM16, false },
+ { DataType::QASYMM16, false },
+ { DataType::U32, false },
+ { DataType::S32, false },
+ { DataType::U64, false },
+ { DataType::S64, false },
+ { DataType::BFLOAT16, false },
+ { DataType::F16, true },
+ { DataType::F32, true },
+ { DataType::F64, false },
+ { DataType::SIZET, false },
+ };
+ Status result{};
+ for(auto &kv : supported_data_types)
+ {
+ const auto input = TensorInfo{ default_input_shape, 1, kv.first, default_data_layout };
+ const auto output = TensorInfo{ default_output_shape, 1, kv.first, default_data_layout };
- // Create tensors
- CLTensor src = create_tensor<CLTensor>(shape, data_type);
- TensorShape shape_scaled(shape);
- shape_scaled.set(0, shape[0] * scale_x);
- shape_scaled.set(1, shape[1] * scale_y);
- CLTensor dst = create_tensor<CLTensor>(shape_scaled, data_type);
-
- ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
- ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
-
- // Create and configure function
- CLScale clscale;
- clscale.configure(&src, &dst, ScaleKernelInfo{ policy, border_mode, constant_border_value, sampling_policy });
-
- // Get border size depending on border mode
- const BorderSize border_size(border_mode == BorderMode::UNDEFINED ? 0 : 1);
-
- // Validate valid region
- const ValidRegion dst_valid_region = calculate_valid_region_scale(*(src.info()), shape_scaled, policy, sampling_policy, (border_mode == BorderMode::UNDEFINED));
- validate(dst.info()->valid_region(), dst_valid_region);
-
- // Validate padding
- PaddingCalculator calculator(shape_scaled.x(), 4);
- calculator.set_border_mode(border_mode);
-
- const PaddingSize read_padding(border_size);
- const PaddingSize write_padding = calculator.required_padding(PaddingCalculator::Option::EXCLUDE_BORDER);
- validate(src.info()->padding(), read_padding);
- validate(dst.info()->padding(), write_padding);
+ result = CLScale::validate(&input, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == kv.second, framework::LogLevel::ERRORS);
+ }
}
+TEST_CASE(SameInputOutput, framework::DatasetMode::ALL)
+{
+ const auto input = TensorInfo{ default_input_shape, 1, default_data_type, default_data_layout };
+ Status result{};
+
+ result = CLScale::validate(&input, &input, ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
+TEST_CASE(MissmatchingDataType, framework::DatasetMode::ALL)
+{
+ constexpr auto non_default_data_type = DataType::F32;
+
+ const auto input = TensorInfo{ default_input_shape, 1, default_data_type, default_data_layout };
+ const auto output = TensorInfo{ default_output_shape, 1, non_default_data_type, default_data_layout };
+ Status result{};
+
+ result = CLScale::validate(&input, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
+TEST_CASE(AlignedCornerNotSupported, framework::DatasetMode::ALL)
+{
+ // Aligned corners require sampling policy to be TOP_LEFT.
+ constexpr auto interpolation_policy = InterpolationPolicy::BILINEAR;
+ constexpr bool align_corners = true;
+ constexpr auto sampling_policy = SamplingPolicy::CENTER;
+
+ const auto input = TensorInfo{ default_input_shape, 1, default_data_type, default_data_layout };
+ const auto output = TensorInfo{ default_output_shape, 1, default_data_type, default_data_layout };
+ Status result{};
+
+ result = CLScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), sampling_policy, default_use_padding, align_corners });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
+TEST_CASE(InvalidAlignedCornerOutput, framework::DatasetMode::ALL)
+{
+ // Bilinear with aligned corners require at least 2x2 output to prevent overflow.
+ // Also, aligned corners require sampling policy to be TOP_LEFT.
+ constexpr auto interpolation_policy = InterpolationPolicy::BILINEAR;
+ constexpr bool align_corners = true;
+ constexpr auto sampling_policy = SamplingPolicy::TOP_LEFT;
+ const auto invalid_output_shape = TensorShape{ 1, 1, 3, 2 };
+
+ const auto input = TensorInfo{ default_input_shape, 1, default_data_type, default_data_layout };
+ const auto output = TensorInfo{ invalid_output_shape, 1, default_data_type, default_data_layout };
+ Status result{};
+
+ result = CLScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), sampling_policy, default_use_padding, align_corners });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
+TEST_CASE(WindowShrink, framework::DatasetMode::ALL)
+{
+ const auto input = TensorInfo{ TensorShape(37U, 37U, 2U), 1, DataType::F32 };
+ const auto output = TensorInfo{ TensorShape(39U, 55U, 2U), 1, DataType::F32 };
+ Status result{};
+
+ result = CLScale::validate(&input.clone()->set_is_resizable(false), &output.clone()->set_is_resizable(false), ScaleKernelInfo{ default_interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
+TEST_CASE(IncorrectScaleFactor, framework::DatasetMode::ALL)
+{
+ const auto input = TensorInfo{ TensorShape(28U, 33U, 2U), 1, DataType::F32 };
+ const auto output = TensorInfo{ TensorShape(26U, 21U, 2U), 1, DataType::F32 };
+ constexpr auto interpolation_policy = InterpolationPolicy::AREA;
+ Status result{};
+
+ result = CLScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+TEST_SUITE_END() // Validate
+
template <typename T>
using CLScaleFixture = ScaleValidationFixture<CLTensor, CLAccessor, CLScale, T>;
TEST_SUITE(Float)
TEST_SUITE(FP32)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleFixture<float>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::F32)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto f32_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<float>())), framework::dataset::make("DataType", DataType::F32));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -191,12 +241,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32, tolerance_f32_absolute);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleFixture<float>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::F32)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -205,12 +250,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32, tolerance_f32_absolute);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
- DataType::F32)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto f32_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<float>())), framework::dataset::make("DataType", DataType::F32));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleFixture<float>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(f32_nightly_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -219,13 +260,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32, tolerance_f32_absolute);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::F32)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleFixture<float>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(f32_nightly_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -236,12 +271,8 @@
}
TEST_SUITE_END() // FP32
TEST_SUITE(FP16)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::F16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto f16_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<half>())), framework::dataset::make("DataType", DataType::F16));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -250,12 +281,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f16);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::F16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -264,12 +290,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f16);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleFixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
- DataType::F16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto f16_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<half>())), framework::dataset::make("DataType", DataType::F16));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleFixture<half>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(f16_nightly_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -278,13 +300,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_f16);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleFixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::F16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleFixture<half>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(f16_nightly_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -298,12 +314,8 @@
TEST_SUITE(Integer)
TEST_SUITE(U8)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::U8)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto u8_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::U8));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -312,13 +324,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType",
- DataType::U8)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -327,12 +333,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
- DataType::U8)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto u8_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::U8));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleFixture<uint8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(u8_nightly_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -341,13 +343,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::U8)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleFixture<uint8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(u8_nightly_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -358,12 +354,8 @@
}
TEST_SUITE_END() // U8
TEST_SUITE(S16)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleFixture<int16_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(), framework::dataset::make("DataType",
- DataType::S16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto s16_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<int16_t>())), framework::dataset::make("DataType", DataType::S16));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -372,13 +364,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_s16);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleFixture<int16_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType",
- DataType::S16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -387,12 +373,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_s16);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
- DataType::S16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto s16_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<int16_t>())), framework::dataset::make("DataType", DataType::S16));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleFixture<int16_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(s16_nightly_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -401,13 +383,7 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_s16);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::S16)),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleFixture<int16_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_DATASET(s16_nightly_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -423,14 +399,8 @@
using CLScaleQuantizedFixture = ScaleValidationQuantizedFixture<CLTensor, CLAccessor, CLScale, T>;
TEST_SUITE(Quantized)
TEST_SUITE(QASYMM8)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType",
- DataType::QASYMM8)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto qasymm8_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::QASYMM8));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -439,14 +409,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType",
- DataType::QASYMM8)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -455,14 +419,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::QASYMM8)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto qasymm8_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::QASYMM8));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_QUANTIZED_DATASET(qasymm8_nightly_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -471,14 +429,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_q8);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType",
- DataType::QASYMM8)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleQuantizedFixture<uint8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_QUANTIZED_DATASET(qasymm8_nightly_shape, ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -489,13 +441,8 @@
}
TEST_SUITE_END() // QASYMM8
TEST_SUITE(QASYMM8_SIGNED)
-FIXTURE_DATA_TEST_CASE(RunSmall, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto qasymm8_signed_shape = combine((SCALE_PRECOMMIT_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED));
+FIXTURE_DATA_TEST_CASE(Run, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -504,13 +451,8 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_qs8);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(datasets::Tiny4DShapes(),
- framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunAlignCorners, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -519,13 +461,9 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_qs8);
}
-FIXTURE_DATA_TEST_CASE(RunLarge, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- SamplingPolicySet))
+const auto qasymm8_signed_nightly_shape = combine((SCALE_NIGHTLY_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED));
+FIXTURE_DATA_TEST_CASE(RunNightly, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_nightly_shape, ScaleSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -534,13 +472,9 @@
// Validate output
validate(CLAccessor(_target), _reference, valid_region, tolerance_qs8);
}
-FIXTURE_DATA_TEST_CASE(RunLargeAlignCorners, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(combine(combine(datasets::LargeShapes(),
- framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
- framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, -1) })),
- framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })),
- framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::NEAREST_NEIGHBOR, InterpolationPolicy::BILINEAR })),
- datasets::BorderModes()),
- AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunNightlyAlignCorners, CLScaleQuantizedFixture<int8_t>, framework::DatasetMode::NIGHTLY, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_nightly_shape,
+ ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
diff --git a/tests/validation/NEON/Scale.cpp b/tests/validation/NEON/Scale.cpp
index 29405cc..f4a9b9d 100644
--- a/tests/validation/NEON/Scale.cpp
+++ b/tests/validation/NEON/Scale.cpp
@@ -28,13 +28,9 @@
#include "arm_compute/runtime/TensorAllocator.h"
#include "tests/NEON/Accessor.h"
#include "tests/PaddingCalculator.h"
-#include "tests/datasets/BorderModeDataset.h"
-#include "tests/datasets/InterpolationPolicyDataset.h"
-#include "tests/datasets/SamplingPolicyDataset.h"
-#include "tests/datasets/ShapeDatasets.h"
+#include "tests/datasets/ScaleValidationDataset.h"
#include "tests/framework/Asserts.h"
#include "tests/framework/Macros.h"
-#include "tests/framework/datasets/Datasets.h"
#include "tests/validation/Helpers.h"
#include "tests/validation/Validation.h"
#include "tests/validation/fixtures/ScaleFixture.h"
@@ -47,94 +43,14 @@
{
namespace
{
-using test::datasets::ShapeDataset;
-
-/** Class to generate boundary values for the given template parameters
- * including shapes with large differences between width and height
- */
-template <uint32_t channel, uint32_t batch, uint32_t element_per_vector, uint32_t vector_size>
-class ScaleShapesBaseDataSet : public ShapeDataset
-{
- static constexpr auto boundary_minus_one = element_per_vector * vector_size - 1;
- static constexpr auto boundary_plus_one = element_per_vector * vector_size + 1;
- static constexpr auto small_size = 3;
-
-public:
- // These tensor shapes are NCHW layout, fixture will convert to NHWC.
- ScaleShapesBaseDataSet()
- : ShapeDataset("Shape",
- {
- TensorShape{ small_size, boundary_minus_one, channel, batch },
- TensorShape{ small_size, boundary_plus_one, channel, batch },
- TensorShape{ boundary_minus_one, small_size, channel, batch },
- TensorShape{ boundary_plus_one, small_size, channel, batch },
- TensorShape{ boundary_minus_one, boundary_plus_one, channel, batch },
- TensorShape{ boundary_plus_one, boundary_minus_one, channel, batch },
- })
- {
- }
-};
-
-/** For the single vector, only larger value (+1) than boundary
- * since smaller value (-1) could cause some invalid shapes like
- * - invalid zero size
- * - size 1 which isn't compatible with scale with aligned corners.
- */
-template <uint32_t channel, uint32_t batch, uint32_t element_per_vector>
-class ScaleShapesBaseDataSet<channel, batch, element_per_vector, 1> : public ShapeDataset
-{
- static constexpr auto small_size = 3;
- static constexpr auto boundary_plus_one = element_per_vector + 1;
-
-public:
- // These tensor shapes are NCHW layout, fixture will convert to NHWC.
- ScaleShapesBaseDataSet()
- : ShapeDataset("Shape",
- {
- TensorShape{ small_size, boundary_plus_one, channel, batch },
- TensorShape{ boundary_plus_one, small_size, channel, batch },
- })
- {
- }
-};
-
-/** For the shapes smaller than one vector, only pre-defined tiny shapes
- * are tested (3x2, 2x3) as smaller shapes are more likely to cause
- * issues and easier to debug.
- */
-template <uint32_t channel, uint32_t batch, uint32_t element_per_vector>
-class ScaleShapesBaseDataSet<channel, batch, element_per_vector, 0> : public ShapeDataset
-{
- static constexpr auto small_size = 3;
- static constexpr auto zero_vector_boundary_value = 2;
-
-public:
- // These tensor shapes are NCHW layout, fixture will convert to NHWC.
- ScaleShapesBaseDataSet()
- : ShapeDataset("Shape",
- {
- TensorShape{ small_size, zero_vector_boundary_value, channel, batch },
- TensorShape{ zero_vector_boundary_value, small_size, channel, batch },
- })
- {
- }
-};
-
-/** Generated shaeps
- * - 2D shapes with 0, 1, 2 vector iterations
- * - 3D shapes with 0, 1 vector iterations
- * - 4D shapes with 0 vector iterations
- */
-#define SCALE_SHAPE_DATASET(element_per_vector) \
- concat(concat(concat(concat(concat(ScaleShapesBaseDataSet<1, 1, (element_per_vector), 0>(), \
- ScaleShapesBaseDataSet<1, 1, (element_per_vector), 1>()), \
- ScaleShapesBaseDataSet<1, 1, (element_per_vector), 2>()), \
- ScaleShapesBaseDataSet<3, 3, (element_per_vector), 0>()), \
- ScaleShapesBaseDataSet<3, 3, (element_per_vector), 1>()), \
- ScaleShapesBaseDataSet<3, 7, (element_per_vector), 0>())
+using datasets::ScaleShapesBaseDataSet;
+using datasets::ScaleInterpolationPolicySet;
+using datasets::ScaleDataLayouts;
+using datasets::ScaleSamplingPolicySet;
+using datasets::ScaleAlignCornersSamplingPolicySet;
/** We consider vector size in byte 64 since the maximum size of
- * a vector used by @ref ScaleKernelInfo is currently 64-byte (float32x4x4).
+ * a vector used by @ref NEScaleKernel is currently 64-byte (float32x4x4).
* There are possibility to reduce test time further by using
* smaller vector sizes for different data types where applicable.
*/
@@ -154,53 +70,12 @@
DataType::F32,
});
-/** Interpolation policy test set */
-const auto InterpolationPolicySet = framework::dataset::make("InterpolationPolicy",
-{
- InterpolationPolicy::NEAREST_NEIGHBOR,
- InterpolationPolicy::BILINEAR,
-});
-
-/** Scale data types */
-const auto ScaleDataLayouts = framework::dataset::make("DataLayout",
-{
- DataLayout::NCHW,
- DataLayout::NHWC,
-});
-
-/** Sampling policy data set */
-const auto SamplingPolicySet = combine(datasets::SamplingPolicies(),
- framework::dataset::make("AlignCorners", { false }));
-
-/** Sampling policy data set for Aligned Corners which only allows TOP_LEFT poicy.*/
-const auto AlignCornersSamplingPolicySet = combine(framework::dataset::make("SamplingPolicy",
-{
- SamplingPolicy::TOP_LEFT,
-}),
-framework::dataset::make("AlignCorners", { true }));
-
-/** Generating dataset for non-quantized data tyeps with the given shapes */
-#define ASSEMBLE_DATASET(shape, samping_policy_set) \
- combine(combine(combine(combine((shape), ScaleDataLayouts), \
- InterpolationPolicySet), \
- datasets::BorderModes()), \
- samping_policy_set)
-
/** Quantization information data set */
const auto QuantizationInfoSet = framework::dataset::make("QuantizationInfo",
{
QuantizationInfo(0.5f, -10),
});
-/** Generating dataset for quantized data tyeps with the given shapes */
-#define ASSEMBLE_QUANTIZED_DATASET(shape, sampling_policy_set) \
- combine(combine(combine(combine(combine(shape, \
- QuantizationInfoSet), \
- ScaleDataLayouts), \
- InterpolationPolicySet), \
- datasets::BorderModes()), \
- sampling_policy_set)
-
/** Tolerance */
constexpr AbsoluteTolerance<uint8_t> tolerance_u8(1);
constexpr AbsoluteTolerance<int16_t> tolerance_s16(1);
@@ -355,6 +230,21 @@
ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
}
+TEST_CASE(AlignedCornerNotSupported, framework::DatasetMode::ALL)
+{
+ // Aligned corners require sampling policy to be TOP_LEFT.
+ constexpr auto interpolation_policy = InterpolationPolicy::BILINEAR;
+ constexpr bool align_corners = true;
+ constexpr auto sampling_policy = SamplingPolicy::CENTER;
+
+ const auto input = TensorInfo{ input_shape, 1, default_data_type, default_data_layout };
+ const auto output = TensorInfo{ output_shape, 1, default_data_type, default_data_layout };
+ Status result{};
+
+ result = NEScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), sampling_policy, default_use_padding, align_corners });
+ ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
+}
+
TEST_CASE(InvalidAlignedCornerOutput, framework::DatasetMode::ALL)
{
// Bilinear with aligned corners require at least 2x2 output to prevent overflow.
@@ -381,7 +271,7 @@
TEST_SUITE(Float)
TEST_SUITE(FP32)
const auto f32_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<float>())), framework::dataset::make("DataType", DataType::F32));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, SamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -390,7 +280,7 @@
// Validate output
validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -403,7 +293,7 @@
#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
TEST_SUITE(FP16)
const auto f16_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<half>())), framework::dataset::make("DataType", DataType::F16));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, SamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -412,7 +302,7 @@
// Validate output
validate(Accessor(_target), _reference, valid_region, tolerance_f16);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -428,7 +318,7 @@
TEST_SUITE(Integer)
TEST_SUITE(U8)
const auto u8_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::U8));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, SamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -437,7 +327,7 @@
// Validate output
validate(Accessor(_target), _reference, valid_region, tolerance_u8);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -449,7 +339,7 @@
TEST_SUITE_END() // U8
TEST_SUITE(S16)
const auto s16_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<int16_t>())), framework::dataset::make("DataType", DataType::S16));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, SamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -458,7 +348,7 @@
// Validate output
validate(Accessor(_target), _reference, valid_region, tolerance_s16, tolerance_num_s16);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleAlignCornersSamplingPolicySet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -473,7 +363,7 @@
TEST_SUITE(Quantized)
TEST_SUITE(QASYMM8)
const auto qasymm8_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<uint8_t>())), framework::dataset::make("DataType", DataType::QASYMM8));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, SamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -482,7 +372,8 @@
// Validate output
validate(Accessor(_target), _reference, valid_region, tolerance_u8);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
@@ -493,24 +384,26 @@
}
TEST_SUITE_END() // QASYMM8
TEST_SUITE(QASYMM8_SIGNED)
-const auto qasymm8_signed_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED));
-FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, SamplingPolicySet))
+const auto qasymm8_signed_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED));
+constexpr AbsoluteTolerance<int8_t> tolerance_qasymm8_signed{ 1 };
+FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
// Validate output
- validate(Accessor(_target), _reference, valid_region, tolerance_u8);
+ validate(Accessor(_target), _reference, valid_region, tolerance_qasymm8_signed);
}
-FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, AlignCornersSamplingPolicySet))
+FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleAlignCornersSamplingPolicySet,
+ QuantizationInfoSet))
{
//Create valid region
TensorInfo src_info(_shape, 1, _data_type);
ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
// Validate output
- validate(Accessor(_target), _reference, valid_region, tolerance_u8);
+ validate(Accessor(_target), _reference, valid_region, tolerance_qasymm8_signed);
}
TEST_SUITE_END() // QASYMM8_SIGNED
TEST_SUITE_END() // Quantized