1 /*
2 * Copyright (c) 2017-2022 Arm Limited.
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24 #include "arm_compute/core/Helpers.h"
25 #include "arm_compute/runtime/NEON/functions/NEScale.h"
26 #include "tests/NEON/Accessor.h"
27 #include "tests/datasets/ScaleValidationDataset.h"
28 #include "tests/framework/Macros.h"
29 #include "tests/validation/Validation.h"
30 #include "tests/validation/fixtures/ScaleFixture.h"
31
32 namespace arm_compute
33 {
34 namespace test
35 {
36 namespace validation
37 {
38 namespace
39 {
40 using datasets::ScaleShapesBaseDataSet;
41 using datasets::ScaleInterpolationPolicySet;
42 using datasets::ScaleDataLayouts;
43 using datasets::ScaleSamplingPolicySet;
44 using datasets::ScaleAlignCornersSamplingPolicySet;
45
46 /** We consider vector size in byte 64 since the maximum size of
47 * a vector used by the kernel is currently 64-byte (float32x4x4).
48 * There is possibility to reduce test time further by using
49 * smaller vector sizes for different data types where applicable.
50 */
51 constexpr uint32_t vector_byte = 64;
52
53 template <typename T>
num_elements_per_vector()54 constexpr uint32_t num_elements_per_vector()
55 {
56 return vector_byte / sizeof(T);
57 }
58
59 /** Quantization information data set */
60 const auto QuantizationInfoSet = framework::dataset::make("QuantizationInfo",
61 {
62 QuantizationInfo(0.5f, -10),
63 });
64
65 /** Quantization information data set */
66 const auto InputQuantizationInfoSet = framework::dataset::make("InputQuantizationInfo",
67 {
68 QuantizationInfo(0.5f, -10),
69 });
70
71 /** Quantization information data set */
72 const auto OutputQuantizationInfoSet = framework::dataset::make("OutputQuantizationInfo",
73 {
74 QuantizationInfo(0.2f, 20),
75 });
76
77 /** Tolerance */
78 constexpr AbsoluteTolerance<uint8_t> tolerance_u8(1);
79 constexpr AbsoluteTolerance<int8_t> tolerance_s8(1);
80 constexpr AbsoluteTolerance<int16_t> tolerance_s16(1);
81 RelativeTolerance<float> tolerance_f32(0.05);
82 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
83 constexpr float abs_tolerance_f16(0.01f);
84 RelativeTolerance<half> tolerance_f16(half(0.1));
85 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
86
87 constexpr float tolerance_num_s16 = 0.01f;
88 constexpr float tolerance_num_f32 = 0.01f;
89 } // namespace
90
91 TEST_SUITE(NEON)
TEST_SUITE(Scale)92 TEST_SUITE(Scale)
93 TEST_SUITE(Validate)
94
95 /** Validate test suite is to test ARM_COMPUTE_RETURN_ON_* macros
96 * we use to check the validity of given arguments in @ref NEScale
97 * Since this is using validate() of @ref NEScale, which pre-adjust
98 * arguments for the kernel, the following conditions in
99 * the kernel are not currently tested.
100 * - The same input and output
101 * - Data type of offset, dx and dy
102 * This suite also tests two different validate() APIs - one is
103 * using @ref ScaleKernelInfo and the other one is more verbose
104 * one calls the other one - in the same test case. Even though
105 * there are possibility that it makes debugging for regression
106 * harder, belows are reasons of this test case implementation.
107 * - The more verbose one is just a wrapper function calls
108 * the other one without any additional logic. So we are
109 * safe to merge two tests into one.
110 * - A large amount of code duplication is test suite can be prevented.
111 */
112
113 const auto input_shape = TensorShape{ 2, 3, 3, 2 };
114 const auto output_shape = TensorShape{ 4, 6, 3, 2 };
115
116 constexpr auto default_data_type = DataType::U8;
117 constexpr auto default_data_layout = DataLayout::NHWC;
118 constexpr auto default_interpolation_policy = InterpolationPolicy::NEAREST_NEIGHBOR;
119 constexpr auto default_border_mode = BorderMode::CONSTANT;
120 constexpr auto default_sampling_policy = SamplingPolicy::CENTER;
121
TEST_CASE(NullPtr,framework::DatasetMode::ALL)122 TEST_CASE(NullPtr, framework::DatasetMode::ALL)
123 {
124 const auto input = TensorInfo{ input_shape, 1, default_data_type, default_data_layout };
125 const auto output = TensorInfo{ output_shape, 1, default_data_type, default_data_layout };
126 Status result{};
127
128 // nullptr is given as input
129 result = NEScale::validate(nullptr, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
130 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
131
132 // nullptr is given as output
133 result = NEScale::validate(&input, nullptr, ScaleKernelInfo{ default_interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
134 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
135 }
136
TEST_CASE(SupportDataType,framework::DatasetMode::ALL)137 TEST_CASE(SupportDataType, framework::DatasetMode::ALL)
138 {
139 const std::map<DataType, bool> supported_data_types =
140 {
141 { DataType::U8, true },
142 { DataType::S8, false },
143 { DataType::QSYMM8, false },
144 { DataType::QASYMM8, true },
145 { DataType::QASYMM8_SIGNED, true },
146 { DataType::QSYMM8_PER_CHANNEL, false },
147 { DataType::U16, false },
148 { DataType::S16, true },
149 { DataType::QSYMM16, false },
150 { DataType::QASYMM16, false },
151 { DataType::U32, false },
152 { DataType::S32, false },
153 { DataType::U64, false },
154 { DataType::S64, false },
155 { DataType::BFLOAT16, false },
156 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
157 { DataType::F16, true },
158 #else // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
159 { DataType::F16, false },
160 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
161 { DataType::F32, true },
162 { DataType::F64, false },
163 { DataType::SIZET, false },
164 };
165 Status result{};
166 for(auto &kv : supported_data_types)
167 {
168 const auto input = TensorInfo{ input_shape, 1, kv.first, default_data_layout };
169 const auto output = TensorInfo{ output_shape, 1, kv.first, default_data_layout };
170
171 result = NEScale::validate(&input, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
172 ARM_COMPUTE_EXPECT(bool(result) == kv.second, framework::LogLevel::ERRORS);
173 }
174 }
175
TEST_CASE(MissmatchingDataType,framework::DatasetMode::ALL)176 TEST_CASE(MissmatchingDataType, framework::DatasetMode::ALL)
177 {
178 constexpr auto non_default_data_type = DataType::F32;
179
180 const auto input = TensorInfo{ input_shape, 1, default_data_type, default_data_layout };
181 const auto output = TensorInfo{ output_shape, 1, non_default_data_type, default_data_layout };
182 Status result{};
183
184 result = NEScale::validate(&input, &output, ScaleKernelInfo{ default_interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
185 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
186 }
187
TEST_CASE(UsePadding,framework::DatasetMode::ALL)188 TEST_CASE(UsePadding, framework::DatasetMode::ALL)
189 {
190 const auto input = TensorInfo{ input_shape, 1, default_data_type, default_data_layout };
191 const auto output = TensorInfo{ output_shape, 1, default_data_type, default_data_layout };
192 Status result{};
193
194 // Padding is not supported anymore
195 constexpr auto border_mode = BorderMode::CONSTANT;
196 constexpr bool use_padding = true;
197
198 result = NEScale::validate(&input, &output, ScaleKernelInfo{ default_interpolation_policy, border_mode, PixelValue(), default_sampling_policy, use_padding });
199 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
200 }
201
TEST_CASE(AreaWithNHWC,framework::DatasetMode::ALL)202 TEST_CASE(AreaWithNHWC, framework::DatasetMode::ALL)
203 {
204 // InterpolationPolicy::AREA is not supported for NHWC
205 constexpr auto interpolation_policy = InterpolationPolicy::AREA;
206 constexpr auto data_layout = DataLayout::NHWC;
207
208 const auto input = TensorInfo{ input_shape, 1, default_data_type, data_layout };
209 const auto output = TensorInfo{ output_shape, 1, default_data_type, data_layout };
210 Status result{};
211
212 result = NEScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
213 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
214 }
215
TEST_CASE(AreaWithNonU8,framework::DatasetMode::ALL)216 TEST_CASE(AreaWithNonU8, framework::DatasetMode::ALL)
217 {
218 // InterpolationPolicy::AREA only supports U8
219 constexpr auto interpolation_policy = InterpolationPolicy::AREA;
220 constexpr auto data_type = DataType::F32;
221 constexpr auto data_layout = DataLayout::NCHW;
222
223 const auto input = TensorInfo{ input_shape, 1, data_type, data_layout };
224 const auto output = TensorInfo{ output_shape, 1, data_type, data_layout };
225 Status result{};
226
227 result = NEScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), SamplingPolicy::CENTER, false });
228 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
229 }
230
TEST_CASE(AlignedCornerNotSupported,framework::DatasetMode::ALL)231 TEST_CASE(AlignedCornerNotSupported, framework::DatasetMode::ALL)
232 {
233 // Aligned corners require sampling policy to be TOP_LEFT.
234 constexpr auto interpolation_policy = InterpolationPolicy::BILINEAR;
235 constexpr bool align_corners = true;
236 constexpr auto sampling_policy = SamplingPolicy::CENTER;
237
238 const auto input = TensorInfo{ input_shape, 1, default_data_type, default_data_layout };
239 const auto output = TensorInfo{ output_shape, 1, default_data_type, default_data_layout };
240 Status result{};
241
242 result = NEScale::validate(&input, &output, ScaleKernelInfo{ interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false, align_corners });
243 ARM_COMPUTE_EXPECT(bool(result) == false, framework::LogLevel::ERRORS);
244 }
245 TEST_SUITE_END() // Validate
246
247 DATA_TEST_CASE(CheckNoPadding, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::Medium4DShapes(),
248 framework::dataset::make("DataType", { DataType::F32, DataType::QASYMM8 })),
249 framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::BILINEAR, InterpolationPolicy::NEAREST_NEIGHBOR })),
250 framework::dataset::make("SamplingPolicy", { SamplingPolicy::CENTER, SamplingPolicy::TOP_LEFT })),
251 framework::dataset::make("DataLayout", { DataLayout::NHWC, DataLayout::NCHW })),
252 shape, data_type, interpolation_policy, sampling_policy, data_layout)
253 {
254 constexpr auto default_border_mode = BorderMode::CONSTANT;
255 ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false);
256
257 // Create tensors
258 Tensor src = create_tensor<Tensor>(shape, data_type);
259 src.info()->set_data_layout(data_layout);
260
261 const float scale_x = 0.5f;
262 const float scale_y = 0.5f;
263 TensorShape shape_scaled(shape);
264 const int idx_width = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
265 const int idx_height = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
266 shape_scaled.set(idx_width, shape[idx_width] * scale_x, /* apply_dim_correction = */ false);
267 shape_scaled.set(idx_height, shape[idx_height] * scale_y, /* apply_dim_correction = */ false);
268 Tensor dst = create_tensor<Tensor>(shape_scaled, data_type);
269
270 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
271 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
272
273 // Create and configure function
274 NEScale scale;
275 scale.configure(&src, &dst, info);
276
277 validate(src.info()->padding(), PaddingSize(0, 0, 0, 0));
278 validate(dst.info()->padding(), PaddingSize(0, 0, 0, 0));
279 }
280
281 DATA_TEST_CASE(CheckNoPaddingInterpAREA, framework::DatasetMode::ALL, combine(combine(combine(combine(datasets::Medium4DShapes(),
282 framework::dataset::make("DataType", { DataType::U8 })),
283 framework::dataset::make("InterpolationPolicy", { InterpolationPolicy::AREA })),
284 framework::dataset::make("SamplingPolicy", { SamplingPolicy::CENTER, SamplingPolicy::TOP_LEFT })),
285 framework::dataset::make("DataLayout", { DataLayout::NCHW })),
286 shape, data_type, interpolation_policy, sampling_policy, data_layout)
287 {
288 constexpr auto default_border_mode = BorderMode::CONSTANT;
289 ScaleKernelInfo info(interpolation_policy, default_border_mode, PixelValue(), sampling_policy, false);
290
291 // Create tensors
292 Tensor src = create_tensor<Tensor>(shape, data_type);
293 src.info()->set_data_layout(data_layout);
294
295 const float scale_x = 0.5f;
296 const float scale_y = 0.5f;
297 TensorShape shape_scaled(shape);
298 const int idx_width = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
299 const int idx_height = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
300 shape_scaled.set(idx_width, shape[idx_width] * scale_x, /* apply_dim_correction = */ false);
301 shape_scaled.set(idx_height, shape[idx_height] * scale_y, /* apply_dim_correction = */ false);
302
303 Tensor dst = create_tensor<Tensor>(shape, data_type);
304
305 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
306 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
307
308 // Create and configure function
309 NEScale scale;
310 scale.configure(&src, &dst, info);
311
312 validate(src.info()->padding(), PaddingSize(0, 0, 0, 0));
313 validate(dst.info()->padding(), PaddingSize(0, 0, 0, 0));
314 }
315
316 template <typename T>
317 using NEScaleFixture = ScaleValidationFixture<Tensor, Accessor, NEScale, T>;
318 template <typename T>
319 using NEScaleMixedDataLayoutFixture = ScaleValidationFixture<Tensor, Accessor, NEScale, T, true>;
320 template <typename T>
321 using NEScaleQuantizedFixture = ScaleValidationQuantizedFixture<Tensor, Accessor, NEScale, T>;
322 template <typename T>
323 using NEScaleDifferentOutputQuantizedFixture = ScaleValidationDifferentOutputQuantizedFixture<Tensor, Accessor, NEScale, T>;
324 template <typename T>
325 using NEScaleQuantizedMixedDataLayoutFixture = ScaleValidationQuantizedFixture<Tensor, Accessor, NEScale, T, true>;
326
327 TEST_SUITE(Float)
328 TEST_SUITE(FP32)
329 const auto f32_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<float>())), framework::dataset::make("DataType", DataType::F32));
330 const auto f32_shape_nhwc = combine(datasets::Small3DShapes(), framework::dataset::make("DataType", DataType::F32));
FIXTURE_DATA_TEST_CASE(RunSmall,NEScaleFixture<float>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (f32_shape,ScaleSamplingPolicySet))331 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleSamplingPolicySet))
332 {
333 //Create valid region
334 TensorInfo src_info(_shape, 1, _data_type);
335 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
336
337 // Validate output
338 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
339 }
FIXTURE_DATA_TEST_CASE(RunMixedDataLayout,NEScaleMixedDataLayoutFixture<float>,framework::DatasetMode::PRECOMMIT,ASSEMBLE_DATASET (f32_shape,ScaleSamplingPolicySet))340 FIXTURE_DATA_TEST_CASE(RunMixedDataLayout, NEScaleMixedDataLayoutFixture<float>, framework::DatasetMode::PRECOMMIT, ASSEMBLE_DATASET(f32_shape, ScaleSamplingPolicySet))
341 {
342 //Create valid region
343 TensorInfo src_info(_shape, 1, _data_type);
344 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
345
346 // Validate output
347 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
348 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleFixture<float>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (f32_shape,ScaleAlignCornersSamplingPolicySet))349 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f32_shape, ScaleAlignCornersSamplingPolicySet))
350 {
351 //Create valid region
352 TensorInfo src_info(_shape, 1, _data_type);
353 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
354
355 // Validate output
356 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
357 }
FIXTURE_DATA_TEST_CASE(RunMediumNHWC,NEScaleFixture<float>,framework::DatasetMode::ALL,ASSEMBLE_NHWC_DATASET (f32_shape_nhwc,ScaleSamplingPolicySet))358 FIXTURE_DATA_TEST_CASE(RunMediumNHWC, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_NHWC_DATASET(f32_shape_nhwc, ScaleSamplingPolicySet))
359 {
360 //Create valid region
361 TensorInfo src_info(_shape, 1, _data_type);
362 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
363
364 // Validate output
365 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
366 }
FIXTURE_DATA_TEST_CASE(RunMediumMixedDataLayoutNHWC,NEScaleMixedDataLayoutFixture<float>,framework::DatasetMode::PRECOMMIT,ASSEMBLE_NHWC_DATASET (f32_shape_nhwc,ScaleSamplingPolicySet))367 FIXTURE_DATA_TEST_CASE(RunMediumMixedDataLayoutNHWC, NEScaleMixedDataLayoutFixture<float>, framework::DatasetMode::PRECOMMIT, ASSEMBLE_NHWC_DATASET(f32_shape_nhwc, ScaleSamplingPolicySet))
368 {
369 //Create valid region
370 TensorInfo src_info(_shape, 1, _data_type);
371 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
372
373 // Validate output
374 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
375 }
FIXTURE_DATA_TEST_CASE(RunMediumAlignCornersNHWC,NEScaleFixture<float>,framework::DatasetMode::ALL,ASSEMBLE_NHWC_DATASET (f32_shape_nhwc,ScaleAlignCornersSamplingPolicySet))376 FIXTURE_DATA_TEST_CASE(RunMediumAlignCornersNHWC, NEScaleFixture<float>, framework::DatasetMode::ALL, ASSEMBLE_NHWC_DATASET(f32_shape_nhwc, ScaleAlignCornersSamplingPolicySet))
377 {
378 //Create valid region
379 TensorInfo src_info(_shape, 1, _data_type);
380 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
381
382 // Validate output
383 validate(Accessor(_target), _reference, valid_region, tolerance_f32, tolerance_num_f32);
384 }
385 TEST_SUITE_END() // FP32
386 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
387 TEST_SUITE(FP16)
388 const auto f16_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<half>())), framework::dataset::make("DataType", DataType::F16));
389 const auto f16_shape_nhwc = combine(datasets::Small3DShapes(), framework::dataset::make("DataType", DataType::F16));
FIXTURE_DATA_TEST_CASE(RunSmall,NEScaleFixture<half>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (f16_shape,ScaleSamplingPolicySet))390 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleSamplingPolicySet))
391 {
392 //Create valid region
393 TensorInfo src_info(_shape, 1, _data_type);
394 const ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
395
396 // Validate output
397 validate(Accessor(_target), _reference, valid_region, tolerance_f16, 0.0f, abs_tolerance_f16);
398 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleFixture<half>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (f16_shape,ScaleAlignCornersSamplingPolicySet))399 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(f16_shape, ScaleAlignCornersSamplingPolicySet))
400 {
401 //Create valid region
402 TensorInfo src_info(_shape, 1, _data_type);
403 const ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
404
405 // Validate output
406 validate(Accessor(_target), _reference, valid_region, tolerance_f16, 0.0f, abs_tolerance_f16);
407 }
FIXTURE_DATA_TEST_CASE(RunMediumNHWC,NEScaleFixture<half>,framework::DatasetMode::ALL,ASSEMBLE_NHWC_DATASET (f16_shape_nhwc,ScaleSamplingPolicySet))408 FIXTURE_DATA_TEST_CASE(RunMediumNHWC, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_NHWC_DATASET(f16_shape_nhwc, ScaleSamplingPolicySet))
409 {
410 //Create valid region
411 TensorInfo src_info(_shape, 1, _data_type);
412 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
413
414 // Validate output
415 validate(Accessor(_target), _reference, valid_region, tolerance_f16, 0.0f, abs_tolerance_f16);
416 }
FIXTURE_DATA_TEST_CASE(RunMediumMixedDataLayoutNHWC,NEScaleMixedDataLayoutFixture<half>,framework::DatasetMode::PRECOMMIT,ASSEMBLE_NHWC_DATASET (f16_shape_nhwc,ScaleSamplingPolicySet))417 FIXTURE_DATA_TEST_CASE(RunMediumMixedDataLayoutNHWC, NEScaleMixedDataLayoutFixture<half>, framework::DatasetMode::PRECOMMIT, ASSEMBLE_NHWC_DATASET(f16_shape_nhwc, ScaleSamplingPolicySet))
418 {
419 //Create valid region
420 TensorInfo src_info(_shape, 1, _data_type);
421 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
422
423 // Validate output
424 validate(Accessor(_target), _reference, valid_region, tolerance_f16, 0.0f, abs_tolerance_f16);
425 }
FIXTURE_DATA_TEST_CASE(RunMediumAlignCornersNHWC,NEScaleFixture<half>,framework::DatasetMode::ALL,ASSEMBLE_NHWC_DATASET (f16_shape_nhwc,ScaleAlignCornersSamplingPolicySet))426 FIXTURE_DATA_TEST_CASE(RunMediumAlignCornersNHWC, NEScaleFixture<half>, framework::DatasetMode::ALL, ASSEMBLE_NHWC_DATASET(f16_shape_nhwc, ScaleAlignCornersSamplingPolicySet))
427 {
428 //Create valid region
429 TensorInfo src_info(_shape, 1, _data_type);
430 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
431
432 // Validate output
433 validate(Accessor(_target), _reference, valid_region, tolerance_f16, 0.0f, abs_tolerance_f16);
434 }
435 TEST_SUITE_END() // FP16
436 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
437 TEST_SUITE_END() // Float
438
439 TEST_SUITE(Integer)
440 TEST_SUITE(U8)
441 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,ScaleSamplingPolicySet))442 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleSamplingPolicySet))
443 {
444 //Create valid region
445 TensorInfo src_info(_shape, 1, _data_type);
446 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
447
448 // Validate output
449 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
450 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleFixture<uint8_t>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (u8_shape,ScaleAlignCornersSamplingPolicySet))451 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(u8_shape, ScaleAlignCornersSamplingPolicySet))
452 {
453 //Create valid region
454 TensorInfo src_info(_shape, 1, _data_type);
455 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
456
457 // Validate output
458 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
459 }
460 TEST_SUITE_END() // U8
461 TEST_SUITE(S8)
462 const auto s8_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::S8));
FIXTURE_DATA_TEST_CASE(RunSmall,NEScaleFixture<int8_t>,framework::DatasetMode::ALL,ASSEMBLE_S8_DATASET (s8_shape,ScaleSamplingPolicySet))463 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_S8_DATASET(s8_shape, ScaleSamplingPolicySet))
464 {
465 //Create valid region
466 TensorInfo src_info(_shape, 1, _data_type);
467 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
468
469 // Validate output
470 validate(Accessor(_target), _reference, valid_region, tolerance_s8);
471 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleFixture<int8_t>,framework::DatasetMode::ALL,ASSEMBLE_S8_DATASET (s8_shape,ScaleAlignCornersSamplingPolicySet))472 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_S8_DATASET(s8_shape, ScaleAlignCornersSamplingPolicySet))
473 {
474 //Create valid region
475 TensorInfo src_info(_shape, 1, _data_type);
476 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
477
478 // Validate output
479 validate(Accessor(_target), _reference, valid_region, tolerance_s8);
480 }
481 TEST_SUITE_END() // S8
482 TEST_SUITE(S16)
483 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,ScaleSamplingPolicySet))484 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleSamplingPolicySet))
485 {
486 //Create valid region
487 TensorInfo src_info(_shape, 1, _data_type);
488 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
489
490 // Validate output
491 validate(Accessor(_target), _reference, valid_region, tolerance_s16, tolerance_num_s16);
492 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleFixture<int16_t>,framework::DatasetMode::ALL,ASSEMBLE_DATASET (s16_shape,ScaleAlignCornersSamplingPolicySet))493 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleFixture<int16_t>, framework::DatasetMode::ALL, ASSEMBLE_DATASET(s16_shape, ScaleAlignCornersSamplingPolicySet))
494 {
495 //Create valid region
496 TensorInfo src_info(_shape, 1, _data_type);
497 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
498
499 // Validate output
500 validate(Accessor(_target), _reference, valid_region, tolerance_s16, tolerance_num_s16);
501 }
502 TEST_SUITE_END() // S16
503 TEST_SUITE_END() // Integer
504
505 TEST_SUITE(Quantized)
506 TEST_SUITE(QASYMM8)
507 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,ScaleSamplingPolicySet,QuantizationInfoSet))508 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
509 {
510 //Create valid region
511 TensorInfo src_info(_shape, 1, _data_type);
512 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
513
514 // Validate output
515 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
516 }
FIXTURE_DATA_TEST_CASE(RunSmallDifferentOutputQuantization,NEScaleDifferentOutputQuantizedFixture<uint8_t>,framework::DatasetMode::ALL,ASSEMBLE_DIFFERENTLY_QUANTIZED_DATASET (qasymm8_shape,ScaleSamplingPolicySet,InputQuantizationInfoSet,OutputQuantizationInfoSet))517 FIXTURE_DATA_TEST_CASE(RunSmallDifferentOutputQuantization, NEScaleDifferentOutputQuantizedFixture<uint8_t>, framework::DatasetMode::ALL,
518 ASSEMBLE_DIFFERENTLY_QUANTIZED_DATASET(qasymm8_shape, ScaleSamplingPolicySet, InputQuantizationInfoSet, OutputQuantizationInfoSet))
519 {
520 //Create valid region
521 TensorInfo src_info(_shape, 1, _data_type);
522 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
523
524 // Validate output
525 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
526 }
FIXTURE_DATA_TEST_CASE(RunMixedDataLayout,NEScaleQuantizedMixedDataLayoutFixture<uint8_t>,framework::DatasetMode::ALL,ASSEMBLE_QUANTIZED_DATASET (qasymm8_shape,ScaleSamplingPolicySet,QuantizationInfoSet))527 FIXTURE_DATA_TEST_CASE(RunMixedDataLayout, NEScaleQuantizedMixedDataLayoutFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleSamplingPolicySet,
528 QuantizationInfoSet))
529 {
530 //Create valid region
531 TensorInfo src_info(_shape, 1, _data_type);
532 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
533
534 // Validate output
535 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
536 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleQuantizedFixture<uint8_t>,framework::DatasetMode::ALL,ASSEMBLE_QUANTIZED_DATASET (qasymm8_shape,ScaleAlignCornersSamplingPolicySet,QuantizationInfoSet))537 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<uint8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_shape, ScaleAlignCornersSamplingPolicySet,
538 QuantizationInfoSet))
539 {
540 //Create valid region
541 TensorInfo src_info(_shape, 1, _data_type);
542 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
543
544 // Validate output
545 validate(Accessor(_target), _reference, valid_region, tolerance_u8);
546 }
547 TEST_SUITE_END() // QASYMM8
548 TEST_SUITE(QASYMM8_SIGNED)
549 const auto qasymm8_signed_shape = combine((SCALE_SHAPE_DATASET(num_elements_per_vector<int8_t>())), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED));
550 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))551 FIXTURE_DATA_TEST_CASE(RunSmall, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleSamplingPolicySet, QuantizationInfoSet))
552 {
553 //Create valid region
554 TensorInfo src_info(_shape, 1, _data_type);
555 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
556
557 // Validate output
558 validate(Accessor(_target), _reference, valid_region, tolerance_qasymm8_signed);
559 }
FIXTURE_DATA_TEST_CASE(RunSmallDifferentOutputQuantization,NEScaleDifferentOutputQuantizedFixture<int8_t>,framework::DatasetMode::ALL,ASSEMBLE_DIFFERENTLY_QUANTIZED_DATASET (qasymm8_signed_shape,ScaleSamplingPolicySet,InputQuantizationInfoSet,OutputQuantizationInfoSet))560 FIXTURE_DATA_TEST_CASE(RunSmallDifferentOutputQuantization, NEScaleDifferentOutputQuantizedFixture<int8_t>, framework::DatasetMode::ALL,
561 ASSEMBLE_DIFFERENTLY_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleSamplingPolicySet, InputQuantizationInfoSet, OutputQuantizationInfoSet))
562 {
563 //Create valid region
564 TensorInfo src_info(_shape, 1, _data_type);
565 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
566
567 // Validate output
568 validate(Accessor(_target), _reference, valid_region, tolerance_qasymm8_signed);
569 }
FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners,NEScaleQuantizedFixture<int8_t>,framework::DatasetMode::ALL,ASSEMBLE_QUANTIZED_DATASET (qasymm8_signed_shape,ScaleAlignCornersSamplingPolicySet,QuantizationInfoSet))570 FIXTURE_DATA_TEST_CASE(RunSmallAlignCorners, NEScaleQuantizedFixture<int8_t>, framework::DatasetMode::ALL, ASSEMBLE_QUANTIZED_DATASET(qasymm8_signed_shape, ScaleAlignCornersSamplingPolicySet,
571 QuantizationInfoSet))
572 {
573 //Create valid region
574 TensorInfo src_info(_shape, 1, _data_type);
575 ValidRegion valid_region = calculate_valid_region_scale(src_info, _reference.shape(), _policy, _sampling_policy, (_border_mode == BorderMode::UNDEFINED));
576
577 // Validate output
578 validate(Accessor(_target), _reference, valid_region, tolerance_qasymm8_signed);
579 }
580 TEST_SUITE_END() // QASYMM8_SIGNED
581 TEST_SUITE_END() // Quantized
582
583 TEST_SUITE_END() // Scale
584 TEST_SUITE_END() // Neon
585 } // namespace validation
586 } // namespace test
587 } // namespace arm_compute
588