Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ComputeLibrary / 06ea048f062a50404b1b3998a61a45449c2d1f0f / . / tests / validation / CL / Convolution.cpp
blob: eb95d1a29520695207c484b12d233f4076e9bbbb [file] [log] [blame]
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]1/*
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]2 * Copyright (c) 2017-2018 ARM Limited.
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]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/Types.h"
25#include "arm_compute/runtime/CL/functions/CLConvolution.h"
26#include "arm_compute/runtime/Tensor.h"
27#include "arm_compute/runtime/TensorAllocator.h"
28#include "tests/CL/CLAccessor.h"
29#include "tests/PaddingCalculator.h"
30#include "tests/datasets/BorderModeDataset.h"
31#include "tests/datasets/ShapeDatasets.h"
32#include "tests/framework/Asserts.h"
33#include "tests/framework/Macros.h"
34#include "tests/framework/datasets/Datasets.h"
35#include "tests/validation/Validation.h"
36#include "tests/validation/fixtures/ConvolutionFixture.h"
37
38namespace arm_compute
39{
40namespace test
41{
42namespace validation
43{
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]44TEST_SUITE(CL)
45TEST_SUITE(CustomConvolution)
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]46TEST_SUITE(Square3x3)
47DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })),
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]48 datasets::BorderModes()),
49 framework::dataset::make("filter_size", { 3 })),
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]50 shape, output_data_type, border_mode, filter_size)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]51{
52 // Create tensors
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]53 CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
54 CLTensor dst = create_tensor<CLTensor>(shape, output_data_type);
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]55
56 // Create conv matrix
57 int16_t conv[9];
58
59 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
60 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
61
62 // Create and configure function
63 CLConvolution3x3 convolution;
64 convolution.configure(&src, &dst, conv, 0, border_mode);
65
66 // Validate valid region
67 const ValidRegion dst_valid_region = shape_to_valid_region(shape, (border_mode == BorderMode::UNDEFINED), BorderSize(filter_size / 2));
68 validate(dst.info()->valid_region(), dst_valid_region);
69
70 // Validate padding
71 PaddingCalculator calculator(shape.x(), 8);
72 calculator.set_border_size(1);
73 calculator.set_border_mode(border_mode);
74
75 const PaddingSize dst_padding = calculator.required_padding();
76
77 calculator.set_accessed_elements(16);
78 calculator.set_access_offset(-1);
79
80 const PaddingSize src_padding = calculator.required_padding();
81
82 validate(src.info()->padding(), src_padding);
83 validate(dst.info()->padding(), dst_padding);
84}
85
86template <typename T>
87using CLConvolutionFixture = ConvolutionSquareValidationFixture<CLTensor, CLAccessor, CLConvolution3x3, T>;
88
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]89TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]90FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
91 DataType::U8)),
92 datasets::BorderModes()),
93 framework::dataset::make("filter_size", { 3 })))
94{
95 // Validate output
96 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
97}
98
99FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
100 DataType::U8)),
101 datasets::BorderModes()),
102 framework::dataset::make("filter_size", { 3 })))
103{
104 // Validate output
105 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
106}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]107TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]108
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]109TEST_SUITE(S16)
110FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
111 DataType::S16)),
112 datasets::BorderModes()),
113 framework::dataset::make("filter_size", { 3 })))
114{
115 // Validate output
116 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
117}
118FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
119 DataType::S16)),
120 datasets::BorderModes()),
121 framework::dataset::make("filter_size", { 3 })))
122{
123 // Validate output
124 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
125}
126TEST_SUITE_END()
127TEST_SUITE_END() /* Square 3x3 */
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]128
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]129TEST_SUITE(Square5x5)
130DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })),
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]131 datasets::BorderModes()),
132 framework::dataset::make("filter_size", { 5 })),
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]133 shape, output_data_type, border_mode, filter_size)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]134{
135 // Create tensors
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]136 CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
137 CLTensor dst = create_tensor<CLTensor>(shape, output_data_type);
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]138
139 // Create conv matrix
140 int16_t conv[25];
141
142 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
143 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
144
145 // Create and configure function
146 CLConvolution5x5 convolution;
147 convolution.configure(&src, &dst, conv, 0, border_mode);
148
149 // Validate valid region
150 const ValidRegion dst_valid_region = shape_to_valid_region(shape, (border_mode == BorderMode::UNDEFINED), BorderSize(filter_size / 2));
151 validate(dst.info()->valid_region(), dst_valid_region);
152
153 // Validate padding
154 PaddingCalculator calculator(shape.x(), 8);
155 calculator.set_border_size(2);
156 calculator.set_border_mode(border_mode);
157
158 const PaddingSize dst_padding = calculator.required_padding();
159
160 calculator.set_accessed_elements(16);
161 calculator.set_access_offset(-2);
162
163 const PaddingSize src_padding = calculator.required_padding();
164
165 validate(src.info()->padding(), src_padding);
166 validate(dst.info()->padding(), dst_padding);
167}
168
169template <typename T>
170using CLConvolutionFixture = ConvolutionSquareValidationFixture<CLTensor, CLAccessor, CLConvolution5x5, T>;
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]171
172TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]173FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
174 DataType::U8)),
175 datasets::BorderModes()),
176 framework::dataset::make("filter_size", { 5 })))
177{
178 // Validate output
179 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
180}
181
182FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
183 DataType::U8)),
184 datasets::BorderModes()),
185 framework::dataset::make("filter_size", { 5 })))
186{
187 // Validate output
188 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
189}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]190TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]191
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]192TEST_SUITE(S16)
193FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
194 DataType::S16)),
195 datasets::BorderModes()),
196 framework::dataset::make("filter_size", { 5 })))
197{
198 // Validate output
199 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
200}
201
202FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
203 DataType::S16)),
204 datasets::BorderModes()),
205 framework::dataset::make("filter_size", { 5 })))
206{
207 // Validate output
208 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
209}
210TEST_SUITE_END()
211TEST_SUITE_END() /* Square5x5 */
212
213TEST_SUITE(Square7x7)
214DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })),
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]215 datasets::BorderModes()),
216 framework::dataset::make("filter_size", { 7 })),
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]217 shape, output_data_type, border_mode, filter_size)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]218{
219 // Create tensors
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]220 CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
221 CLTensor dst = create_tensor<CLTensor>(shape, output_data_type);
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]222
223 // Create conv matrix
224 int16_t conv[49];
225
226 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
227 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
228
229 // Create and configure function
230 CLConvolution7x7 convolution;
231 convolution.configure(&src, &dst, conv, 0, border_mode);
232
233 // Validate valid region
234 const ValidRegion dst_valid_region = shape_to_valid_region(shape, (border_mode == BorderMode::UNDEFINED), BorderSize(filter_size / 2));
235 validate(dst.info()->valid_region(), dst_valid_region);
236
237 // Validate padding
238 PaddingCalculator calculator(shape.x(), 8);
239 calculator.set_border_size(3);
240 calculator.set_border_mode(border_mode);
241
242 const PaddingSize dst_padding = calculator.required_padding();
243
244 calculator.set_accessed_elements(16);
245 calculator.set_access_offset(-3);
246
247 const PaddingSize src_padding = calculator.required_padding();
248
249 validate(src.info()->padding(), src_padding);
250 validate(dst.info()->padding(), dst_padding);
251}
252
253template <typename T>
254using CLConvolutionFixture = ConvolutionSquareValidationFixture<CLTensor, CLAccessor, CLConvolution7x7, T>;
255
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]256TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]257FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
258 DataType::U8)),
259 datasets::BorderModes()),
260 framework::dataset::make("filter_size", { 7 })))
261{
262 // Validate output
263 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
264}
265
266FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
267 DataType::U8)),
268 datasets::BorderModes()),
269 framework::dataset::make("filter_size", { 7 })))
270{
271 // Validate output
272 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
273}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]274TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]275
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]276TEST_SUITE(S16)
277FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
278 DataType::S16)),
279 datasets::BorderModes()),
280 framework::dataset::make("filter_size", { 7 })))
281{
282 // Validate output
283 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
284}
285
286FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
287 DataType::S16)),
288 datasets::BorderModes()),
289 framework::dataset::make("filter_size", { 7 })))
290{
291 // Validate output
292 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
293}
294TEST_SUITE_END()
295TEST_SUITE_END() /* Square7x7 */
296
297TEST_SUITE(Square9x9)
298DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType", { DataType::U8, DataType::S16 })),
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]299 datasets::BorderModes()),
300 framework::dataset::make("filter_size", { 9 })),
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]301 shape, output_data_type, border_mode, filter_size)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]302{
303 // Create tensors
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]304 CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
305 CLTensor dst = create_tensor<CLTensor>(shape, output_data_type);
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]306
307 // Create conv matrix
308 int16_t conv[81];
309
310 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
311 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
312
313 // Create and configure function
314 CLConvolution9x9 convolution;
315 convolution.configure(&src, &dst, conv, 0, border_mode);
316
317 // Validate valid region
318 const ValidRegion dst_valid_region = shape_to_valid_region(shape, (border_mode == BorderMode::UNDEFINED), BorderSize(filter_size / 2));
319 validate(dst.info()->valid_region(), dst_valid_region);
320
321 // Validate padding
322 PaddingCalculator calculator(shape.x(), 8);
323 calculator.set_border_size(4);
324 calculator.set_border_mode(border_mode);
325
326 const PaddingSize dst_padding = calculator.required_padding();
327
328 calculator.set_accessed_elements(16);
329 calculator.set_access_offset(-4);
330
331 const PaddingSize src_padding = calculator.required_padding();
332
333 validate(src.info()->padding(), src_padding);
334 validate(dst.info()->padding(), dst_padding);
335}
336
337template <typename T>
338using CLConvolutionFixture = ConvolutionSquareValidationFixture<CLTensor, CLAccessor, CLConvolution9x9, T>;
339
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]340TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]341FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
342 DataType::U8)),
343 datasets::BorderModes()),
344 framework::dataset::make("filter_size", { 9 })))
345{
346 // Validate output
347 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
348}
349
350FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
351 DataType::U8)),
352 datasets::BorderModes()),
353 framework::dataset::make("filter_size", { 9 })))
354{
355 // Validate output
356 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
357}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]358TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]359
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]360TEST_SUITE(S16)
361FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
362 DataType::S16)),
363 datasets::BorderModes()),
364 framework::dataset::make("filter_size", { 9 })))
365{
366 // Validate output
367 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
368}
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]369
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]370FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
371 DataType::S16)),
372 datasets::BorderModes()),
373 framework::dataset::make("filter_size", { 9 })))
374{
375 // Validate output
376 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
377}
378TEST_SUITE_END()
379TEST_SUITE_END() /* Square9x9 */
380
381TEST_SUITE(Rectangle)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]382DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(combine(combine(concat(datasets::SmallShapes(), datasets::LargeShapes()), framework::dataset::make("DataType",
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]383{ DataType::U8, DataType::S16 })),
384datasets::BorderModes()),
385framework::dataset::make("filter_width", { 3, 5, 7, 9 })),
386framework::dataset::make("filter_height", { 3, 5, 7, 9 })),
387shape, output_data_type, border_mode, filter_width, filter_height)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]388{
389 // Create tensors
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]390 CLTensor src = create_tensor<CLTensor>(shape, DataType::U8);
391 CLTensor dst = create_tensor<CLTensor>(shape, output_data_type);
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]392
393 // Create conv matrix
394 int16_t conv[filter_width * filter_height];
395
396 ARM_COMPUTE_EXPECT(src.info()->is_resizable(), framework::LogLevel::ERRORS);
397 ARM_COMPUTE_EXPECT(dst.info()->is_resizable(), framework::LogLevel::ERRORS);
398
399 // Create and configure function
400 CLConvolutionRectangle convolution;
401 convolution.configure(&src, &dst, conv, filter_width, filter_height, 1, border_mode);
402
403 // Validate valid region
404 const ValidRegion dst_valid_region = shape_to_valid_region(shape, (border_mode == BorderMode::UNDEFINED), BorderSize(filter_height / 2, filter_width / 2));
405 validate(dst.info()->valid_region(), dst_valid_region);
406
407 // Validate padding
408 PaddingCalculator calculator(shape.x(), 8);
409 calculator.set_border_size(filter_width / 2);
410 calculator.set_border_mode(border_mode);
411
412 const PaddingSize dst_padding = calculator.required_padding();
413
414 calculator.set_accessed_elements(16);
415 calculator.set_access_offset(-(filter_width / 2));
416
417 const PaddingSize width_padding = calculator.required_padding();
418
419 calculator.set_border_size(filter_height / 2);
420 calculator.set_access_offset(-(filter_height / 2));
421 const PaddingSize height_padding = calculator.required_padding();
422
423 validate(src.info()->padding(), width_padding, height_padding);
424 validate(dst.info()->padding(), dst_padding);
425}
426
427template <typename T>
428using CLConvolutionFixture = ConvolutionRectangleValidationFixture<CLTensor, CLAccessor, CLConvolutionRectangle, T>;
429
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]430TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]431FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
432 DataType::U8)),
433 datasets::BorderModes()),
434 framework::dataset::make("filter_width", { 3, 5, 7, 9 })),
435 framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
436{
437 // Validate output
438 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
439}
440
441FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
442 DataType::U8)),
443 datasets::BorderModes()),
444 framework::dataset::make("filter_width", { 3, 5, 7, 9 })),
445 framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
446{
447 // Validate output
448 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
449}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]450TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]451
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]452TEST_SUITE(S16)
453FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
454 DataType::S16)),
455 datasets::BorderModes()),
456 framework::dataset::make("filter_width", { 3, 5, 7, 9 })),
457 framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
458{
459 // Validate output
460 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
461}
462
463FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
464 DataType::S16)),
465 datasets::BorderModes()),
466 framework::dataset::make("filter_width", { 3, 5, 7, 9 })),
467 framework::dataset::make("filter_height", { 3, 5, 7, 9 })))
468{
469 // Validate output
470 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
471}
472TEST_SUITE_END()
473TEST_SUITE_END() /* Rectangle */
474
475TEST_SUITE(Separable5x5)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]476template <typename T>
477using CLConvolutionFixture = ConvolutionSeparableValidationFixture<CLTensor, CLAccessor, CLConvolution5x5, T>;
478
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]479TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]480FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
481 DataType::U8)),
482 datasets::BorderModes()),
483 framework::dataset::make("filter_size", { 5 })))
484{
485 // Validate output
486 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
487}
488
489FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
490 DataType::U8)),
491 datasets::BorderModes()),
492 framework::dataset::make("filter_size", { 5 })))
493{
494 // Validate output
495 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
496}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]497TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]498
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]499TEST_SUITE(S16)
500FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
501 DataType::S16)),
502 datasets::BorderModes()),
503 framework::dataset::make("filter_size", { 5 })))
504{
505 // Validate output
506 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
507}
508
509FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
510 DataType::S16)),
511 datasets::BorderModes()),
512 framework::dataset::make("filter_size", { 5 })))
513{
514 // Validate output
515 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
516}
517TEST_SUITE_END()
518TEST_SUITE_END() /* Separable5x5 */
519
520TEST_SUITE(Separable7x7)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]521template <typename T>
522using CLConvolutionFixture = ConvolutionSeparableValidationFixture<CLTensor, CLAccessor, CLConvolution7x7, T>;
523
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]524TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]525FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
526 DataType::U8)),
527 datasets::BorderModes()),
528 framework::dataset::make("filter_size", { 7 })))
529{
530 // Validate output
531 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
532}
533
534FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
535 DataType::U8)),
536 datasets::BorderModes()),
537 framework::dataset::make("filter_size", { 7 })))
538{
539 // Validate output
540 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
541}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]542TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]543
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]544TEST_SUITE(S16)
545FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
546 DataType::S16)),
547 datasets::BorderModes()),
548 framework::dataset::make("filter_size", { 7 })))
549{
550 // Validate output
551 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
552}
553
554FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
555 DataType::S16)),
556 datasets::BorderModes()),
557 framework::dataset::make("filter_size", { 7 })))
558{
559 // Validate output
560 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
561}
562TEST_SUITE_END()
563TEST_SUITE_END() /* Separable7x7 */
564
565TEST_SUITE(Separable9x9)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]566template <typename T>
567using CLConvolutionFixture = ConvolutionSeparableValidationFixture<CLTensor, CLAccessor, CLConvolution9x9, T>;
568
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]569TEST_SUITE(U8)
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]570FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
571 DataType::U8)),
572 datasets::BorderModes()),
573 framework::dataset::make("filter_size", { 9 })))
574{
575 // Validate output
576 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
577}
578
579FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
580 DataType::U8)),
581 datasets::BorderModes()),
582 framework::dataset::make("filter_size", { 9 })))
583{
584 // Validate output
585 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
586}
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]587TEST_SUITE_END()
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]588
Anthony Barbier06ea0482018-02-22 15:45:35 +0000[diff] [blame^]589TEST_SUITE(S16)
590FIXTURE_DATA_TEST_CASE(RunSmall, CLConvolutionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
591 DataType::S16)),
592 datasets::BorderModes()),
593 framework::dataset::make("filter_size", { 9 })))
594{
595 // Validate output
596 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
597}
598
599FIXTURE_DATA_TEST_CASE(RunLarge, CLConvolutionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
600 DataType::S16)),
601 datasets::BorderModes()),
602 framework::dataset::make("filter_size", { 9 })))
603{
604 // Validate output
605 validate(CLAccessor(_target), _reference, shape_to_valid_region(_reference.shape(), (_border_mode == BorderMode::UNDEFINED), BorderSize(_height / 2, _width / 2)));
606}
607TEST_SUITE_END()
608TEST_SUITE_END() /* Separable9x9 */
609
Anthony Barbierf45d5a92018-01-24 16:23:15 +0000[diff] [blame]610TEST_SUITE_END() /* Custom Convolution */
611TEST_SUITE_END()
612} // namespace validation
613} // namespace test
614} // namespace arm_compute