1 /*
2 * Copyright (c) 2019-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 "src/cpu/kernels/CpuDepthwiseConv2dNativeKernel.h"
25 #include "tests/NEON/Accessor.h"
26 #include "tests/NEON/Helper.h"
27 #include "tests/framework/Macros.h"
28 #include "tests/framework/datasets/Datasets.h"
29 #include "tests/validation/Validation.h"
30 #include "tests/validation/fixtures/DepthwiseConvolutionLayerFixture.h"
31
32 namespace arm_compute
33 {
34 namespace test
35 {
36 namespace validation
37 {
38 using namespace arm_compute::misc::shape_calculator;
39
40 // Create function for CpuDepthwiseConvolutionKernel
41 using CpuDepthwiseConvolutionNative = NESynthetizeFunctionWithZeroConstantKernelBorder<cpu::kernels::CpuDepthwiseConv2dNativeKernel>;
42
43 // Fixture for NEDepthwiseConvolutionLayerKernel
44 template <typename T>
45 using CpuDepthwiseConvolutionNativeFixture = DepthwiseConvolutionLayerNativeValidationFixture<Tensor, Accessor, CpuDepthwiseConvolutionNative, T>;
46
47 namespace
48 {
49 // *INDENT-OFF*
50 // clang-format off
51 RelativeTolerance<float> rel_tolerance_f32(0.001f);
52 constexpr float abs_tolerance_f32(0.0001f);
53
54 /** Width values to test - Precommit */
55 const auto width_values_precommit = framework::dataset::make("width", { 17U } );
56
57 /** Width values to test - Nightly */
58 const auto width_values_nightly = framework::dataset::make("width", { 53U, 47U } );
59
60 /** Height values to test - Precommit */
61 const auto height_values_precommit = framework::dataset::make("height", { 19U } );
62
63 /** Height values to test - Nightly */
64 const auto height_values_nightly = framework::dataset::make("height", { 39U, 43U } );
65
66 /** Channel values to test - Precommit */
67 const auto channel_values_precommit = framework::dataset::make("channels", { 15U });
68
69 /** Channel values to test - Nightly */
70 const auto channel_values_nightly = framework::dataset::make("channels", { 33U, 19U });
71
72 /** Batch values to test - Precommit */
73 const auto batch_values_precommit = framework::dataset::make("batch", { 1U, 2U });
74
75 /** Batch values to test - Nightly */
76 const auto batch_values_nightly = framework::dataset::make("batch", { 1U, 3U });
77
78 /** Kernel size values to test - Precommit */
79 const auto kernel_sz_values_precommit = framework::dataset::make("kernel_size", { Size2D(1U, 1U), Size2D(1U, 3U) });
80
81 /** Kernel size values to test - Nightly */
82 const auto kernel_sz_values_nightly = framework::dataset::make("kernel_size", { Size2D(3U, 5U), Size2D(5U, 1U), Size2D(1U, 7U), Size2D(9U, 7U) });
83
84 /** Depth multiplier values to test - All */
85 const auto depth_multiplier_values = framework::dataset::make("depth_multiplier", { 1U, 3U });
86
87 /** Dilation values to test - All */
88 const auto dilation_values = framework::dataset::make("dilation", { Size2D(1U, 1U), Size2D(3U, 3U) });
89
90 /** Stride values to test - All */
91 const auto stride_values = framework::dataset::make("stride", { Size2D(1U, 1U), Size2D(3U, 2U) });
92
93 /** Padding values to test - All */
94 const auto padding_valid_values = framework::dataset::make("padding_valid", { true, false });
95
96 /** Data type values to test - All */
97 const auto data_type_values = framework::dataset::make("data_type", { DataType::F32 });
98
99 /** Data layout values to test - All */
100 const auto data_layout_values = framework::dataset::make("data_layout", { DataLayout::NHWC });
101 } // namespace
102
103 TEST_SUITE(NEON)
TEST_SUITE(DepthwiseConvolutionLayerNative)104 TEST_SUITE(DepthwiseConvolutionLayerNative)
105
106 TEST_CASE(ValidateNoPadding, framework::DatasetMode::ALL)
107 {
108 // this test case will ensure that the kernel is not adding implicit padding
109 constexpr uint32_t vector_size = 8; // Asummed vector size of the current native kernel
110 constexpr auto depth = vector_size * 2 + 1; // mis-aligned depth to force padding if exists.
111 constexpr auto data_layout = DataLayout::NHWC;
112 constexpr auto data_type = DataType::F32;
113
114 const auto input_size = Size2D{ 100, 100 }; // random plane size of the input
115 const auto kernel_size = Size2D{ 4, 4 }; // random plane size of the kernel
116 const auto pad_stride_info = PadStrideInfo(3, 3); // random convolution information to
117
118 TensorShape src_shape{ depth, input_size.x(), input_size.y() };
119 TensorShape weights_shape{ depth, kernel_size.x(), kernel_size.y() };
120 TensorShape bias_shape{ depth };
121
122 auto src = create_tensor<Tensor>(src_shape, data_type, 1, QuantizationInfo(), data_layout);
123 auto weights = create_tensor<Tensor>(weights_shape, data_type, 1, QuantizationInfo(), data_layout);
124 auto biases = create_tensor<Tensor>(bias_shape, data_type, 1, QuantizationInfo(), data_layout);
125 auto dst = create_tensor<Tensor>(TensorShape(), data_type, 1, QuantizationInfo(), data_layout);
126
127 cpu::kernels::CpuDepthwiseConv2dNativeKernel dwc;
128 const ConvolutionInfo info{pad_stride_info, 1, ActivationLayerInfo(), Size2D(1, 1)};
129 dwc.configure(src.info(), weights.info(), biases.info(), dst.info(), info);
130
131 ARM_COMPUTE_EXPECT(src.info()->padding().empty(), framework::LogLevel::ERRORS);
132 ARM_COMPUTE_EXPECT(weights.info()->padding().empty(), framework::LogLevel::ERRORS);
133 ARM_COMPUTE_EXPECT(biases.info()->padding().empty(), framework::LogLevel::ERRORS);
134 ARM_COMPUTE_EXPECT(dst.info()->padding().empty(), framework::LogLevel::ERRORS);
135 }
136
137 TEST_SUITE(KERNEL_SELECTION)
138 DATA_TEST_CASE(KernelSelection_mul_and_add, framework::DatasetMode::ALL,
139 combine(combine(framework::dataset::make("CpuExt", std::string("NEON")),
140 framework::dataset::make("DataType", { DataType::F32,
141 DataType::F16,
142 DataType::QASYMM8_SIGNED,
143 DataType::QASYMM8,
144 DataType::QSYMM8_PER_CHANNEL
145 })),
146 framework::dataset::make("DataType_per_channel", { DataType::QASYMM8,
147 DataType::QASYMM8_SIGNED
148 })),
149 cpu_ext, data_type, data_type_per_channel)
150 {
151 using namespace cpu::kernels;
152
153 cpuinfo::CpuIsaInfo cpu_isa{};
154 cpu_isa.neon = (cpu_ext == "NEON");
155 cpu_isa.fp16 = (data_type == DataType::F16);
156
157 const auto *selected_impl = CpuDepthwiseConv2dNativeKernel::get_implementation(
158 DepthwiseConv2dNativeDataTypeISASelectorData{ data_type, data_type_per_channel,cpu_isa },
159 cpu::KernelSelectionType::Preferred );
160
161 ARM_COMPUTE_ERROR_ON_NULLPTR(selected_impl);
162
163 std::string per_channel_str = "_";
164 if (data_type == DataType::QSYMM8_PER_CHANNEL)
165 {
166 per_channel_str = "_" + cpu_impl_dt(data_type_per_channel) + "_" ;
167 }
168 std::string expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + per_channel_str + "deptwiseconv2dnative";
169 std::string actual = selected_impl->name;
170
171 ARM_COMPUTE_EXPECT_EQUAL(expected, actual, framework::LogLevel::ERRORS);
172 }
173 TEST_SUITE_END() // KERNEL_SELECTION
174
TEST_SUITE(Float)175 TEST_SUITE(Float)
176 TEST_SUITE(FP32)
177 FIXTURE_DATA_TEST_CASE_NEW(RunSmall, CpuDepthwiseConvolutionNativeFixture<float>, framework::DatasetMode::ALL,
178 combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_precommit,
179 height_values_precommit),
180 channel_values_precommit),
181 batch_values_precommit),
182 kernel_sz_values_precommit),
183 depth_multiplier_values),
184 dilation_values),
185 stride_values),
186 padding_valid_values),
187 data_type_values),
188 data_layout_values))
189 {
190 // Validate output
191 validate(Accessor(_target), _reference, rel_tolerance_f32, 0.f, abs_tolerance_f32);
192 }
193
FIXTURE_DATA_TEST_CASE_NEW(RunLarge,CpuDepthwiseConvolutionNativeFixture<float>,framework::DatasetMode::NIGHTLY,combine (combine (combine (combine (combine (combine (combine (combine (combine (combine (width_values_nightly,height_values_nightly),channel_values_nightly),batch_values_nightly),kernel_sz_values_nightly),depth_multiplier_values),dilation_values),stride_values),padding_valid_values),data_type_values),data_layout_values))194 FIXTURE_DATA_TEST_CASE_NEW(RunLarge, CpuDepthwiseConvolutionNativeFixture<float>, framework::DatasetMode::NIGHTLY,
195 combine(combine(combine(combine(combine(combine(combine(combine(combine(combine(width_values_nightly,
196 height_values_nightly),
197 channel_values_nightly),
198 batch_values_nightly),
199 kernel_sz_values_nightly),
200 depth_multiplier_values),
201 dilation_values),
202 stride_values),
203 padding_valid_values),
204 data_type_values),
205 data_layout_values))
206 {
207 // Validate output
208 validate(Accessor(_target), _reference, rel_tolerance_f32, 0.f, abs_tolerance_f32);
209 }
210
211 TEST_SUITE_END() // FP32
212 TEST_SUITE_END() // Float
213 TEST_SUITE_END() // DepthwiseConvolutionLayerNative
214 TEST_SUITE_END() // Neon
215 } // namespace validation
216 } // namespace test
217 } // namespace arm_compute
218