1 /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #include <cstdint>
17 #include <functional>
18 #include <memory>
19 #include <random>
20
21 #include <gtest/gtest.h>
22 #include "tensorflow/lite/delegates/xnnpack/pool_2d_tester.h"
23 #include "tensorflow/lite/delegates/xnnpack/xnnpack_delegate.h"
24
25 namespace tflite {
26 namespace xnnpack {
27
TEST(AveragePool2D,UnitPoolSamePadding)28 TEST(AveragePool2D, UnitPoolSamePadding) {
29 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
30 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
31 TfLiteXNNPackDelegateDelete);
32
33 std::random_device random_device;
34 auto rng = std::mt19937(random_device());
35 auto batch_rng =
36 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
37 auto input_rng =
38 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
39 auto channel_rng =
40 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
41
42 Pool2DTester()
43 .BatchSize(batch_rng())
44 .InputHeight(input_rng())
45 .InputWidth(input_rng())
46 .Channels(channel_rng())
47 .PoolingHeight(1)
48 .PoolingWidth(1)
49 .StrideHeight(1)
50 .StrideWidth(1)
51 .SamePadding()
52 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
53 }
54
TEST(AveragePool2D,UnitPoolValidPadding)55 TEST(AveragePool2D, UnitPoolValidPadding) {
56 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
57 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
58 TfLiteXNNPackDelegateDelete);
59
60 std::random_device random_device;
61 auto rng = std::mt19937(random_device());
62 auto batch_rng =
63 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
64 auto input_rng =
65 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
66 auto channel_rng =
67 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
68
69 Pool2DTester()
70 .BatchSize(batch_rng())
71 .InputHeight(input_rng())
72 .InputWidth(input_rng())
73 .Channels(channel_rng())
74 .PoolingHeight(1)
75 .PoolingWidth(1)
76 .StrideHeight(1)
77 .StrideWidth(1)
78 .ValidPadding()
79 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
80 }
81
TEST(AveragePool2D,EqualPoolAndStrideWithSamePadding)82 TEST(AveragePool2D, EqualPoolAndStrideWithSamePadding) {
83 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
84 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
85 TfLiteXNNPackDelegateDelete);
86
87 std::random_device random_device;
88 auto rng = std::mt19937(random_device());
89 auto batch_rng =
90 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
91 auto input_rng =
92 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
93 auto pool_rng =
94 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
95 auto channel_rng =
96 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
97
98 const int32_t pool_height = pool_rng();
99 const int32_t pool_width = pool_rng();
100
101 Pool2DTester()
102 .BatchSize(batch_rng())
103 .InputHeight(input_rng())
104 .InputWidth(input_rng())
105 .Channels(channel_rng())
106 .PoolingHeight(pool_height)
107 .PoolingWidth(pool_width)
108 .StrideHeight(pool_height)
109 .StrideWidth(pool_width)
110 .SamePadding()
111 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
112 }
113
TEST(AveragePool2D,EqualPoolAndStrideWithValidPadding)114 TEST(AveragePool2D, EqualPoolAndStrideWithValidPadding) {
115 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
116 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
117 TfLiteXNNPackDelegateDelete);
118
119 std::random_device random_device;
120 auto rng = std::mt19937(random_device());
121 auto batch_rng =
122 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
123 auto input_rng =
124 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
125 auto pool_rng =
126 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
127 auto channel_rng =
128 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
129
130 const int32_t pool_height = pool_rng();
131 const int32_t pool_width = pool_rng();
132
133 Pool2DTester()
134 .BatchSize(batch_rng())
135 .InputHeight(input_rng())
136 .InputWidth(input_rng())
137 .Channels(channel_rng())
138 .PoolingHeight(pool_height)
139 .PoolingWidth(pool_width)
140 .StrideHeight(pool_height)
141 .StrideWidth(pool_width)
142 .ValidPadding()
143 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
144 }
145
TEST(AveragePool2D,LargePoolSmallStrideWithSamePadding)146 TEST(AveragePool2D, LargePoolSmallStrideWithSamePadding) {
147 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
148 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
149 TfLiteXNNPackDelegateDelete);
150
151 std::random_device random_device;
152 auto rng = std::mt19937(random_device());
153 auto batch_rng =
154 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
155 auto input_rng =
156 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
157 auto pool_rng =
158 std::bind(std::uniform_int_distribution<int32_t>(4, 7), std::ref(rng));
159 auto stride_rng =
160 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
161 auto channel_rng =
162 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
163
164 Pool2DTester()
165 .BatchSize(batch_rng())
166 .InputHeight(input_rng())
167 .InputWidth(input_rng())
168 .Channels(channel_rng())
169 .PoolingHeight(pool_rng())
170 .PoolingWidth(pool_rng())
171 .StrideHeight(stride_rng())
172 .StrideWidth(stride_rng())
173 .SamePadding()
174 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
175 }
176
TEST(AveragePool2D,LargePoolSmallStrideWithValidPadding)177 TEST(AveragePool2D, LargePoolSmallStrideWithValidPadding) {
178 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
179 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
180 TfLiteXNNPackDelegateDelete);
181
182 std::random_device random_device;
183 auto rng = std::mt19937(random_device());
184 auto batch_rng =
185 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
186 auto input_rng =
187 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
188 auto pool_rng =
189 std::bind(std::uniform_int_distribution<int32_t>(4, 7), std::ref(rng));
190 auto stride_rng =
191 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
192 auto channel_rng =
193 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
194
195 Pool2DTester()
196 .BatchSize(batch_rng())
197 .InputHeight(input_rng())
198 .InputWidth(input_rng())
199 .Channels(channel_rng())
200 .PoolingHeight(pool_rng())
201 .PoolingWidth(pool_rng())
202 .StrideHeight(stride_rng())
203 .StrideWidth(stride_rng())
204 .ValidPadding()
205 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
206 }
207
TEST(AveragePool2D,GlobalPooling)208 TEST(AveragePool2D, GlobalPooling) {
209 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
210 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
211 TfLiteXNNPackDelegateDelete);
212
213 std::random_device random_device;
214 auto rng = std::mt19937(random_device());
215 auto batch_rng =
216 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
217 auto input_rng =
218 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
219 auto channel_rng =
220 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
221
222 const int32_t height = input_rng();
223 const int32_t width = input_rng();
224 Pool2DTester()
225 .BatchSize(batch_rng())
226 .InputHeight(height)
227 .InputWidth(width)
228 .Channels(channel_rng())
229 .PoolingHeight(height)
230 .PoolingWidth(width)
231 .ValidPadding()
232 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
233 }
234
TEST(AveragePool2D,ReluActivation)235 TEST(AveragePool2D, ReluActivation) {
236 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
237 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
238 TfLiteXNNPackDelegateDelete);
239
240 std::random_device random_device;
241 auto rng = std::mt19937(random_device());
242 auto batch_rng =
243 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
244 auto input_rng =
245 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
246 auto pool_rng =
247 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
248 auto stride_rng =
249 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
250 auto channel_rng =
251 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
252
253 Pool2DTester()
254 .BatchSize(batch_rng())
255 .InputHeight(input_rng())
256 .InputWidth(input_rng())
257 .Channels(channel_rng())
258 .PoolingHeight(pool_rng())
259 .PoolingWidth(pool_rng())
260 .StrideHeight(stride_rng())
261 .StrideWidth(stride_rng())
262 .ReluActivation()
263 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
264 }
265
TEST(AveragePool2D,Relu6Activation)266 TEST(AveragePool2D, Relu6Activation) {
267 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
268 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
269 TfLiteXNNPackDelegateDelete);
270
271 std::random_device random_device;
272 auto rng = std::mt19937(random_device());
273 auto batch_rng =
274 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
275 auto input_rng =
276 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
277 auto pool_rng =
278 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
279 auto stride_rng =
280 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
281 auto channel_rng =
282 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
283
284 Pool2DTester()
285 .BatchSize(batch_rng())
286 .InputHeight(input_rng())
287 .InputWidth(input_rng())
288 .Channels(channel_rng())
289 .PoolingHeight(pool_rng())
290 .PoolingWidth(pool_rng())
291 .StrideHeight(stride_rng())
292 .StrideWidth(stride_rng())
293 .Relu6Activation()
294 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
295 }
296
TEST(AveragePool2D,ReluMinus1To1Activation)297 TEST(AveragePool2D, ReluMinus1To1Activation) {
298 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
299 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
300 TfLiteXNNPackDelegateDelete);
301
302 std::random_device random_device;
303 auto rng = std::mt19937(random_device());
304 auto batch_rng =
305 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
306 auto input_rng =
307 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
308 auto pool_rng =
309 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
310 auto stride_rng =
311 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
312 auto channel_rng =
313 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
314
315 Pool2DTester()
316 .BatchSize(batch_rng())
317 .InputHeight(input_rng())
318 .InputWidth(input_rng())
319 .Channels(channel_rng())
320 .PoolingHeight(pool_rng())
321 .PoolingWidth(pool_rng())
322 .StrideHeight(stride_rng())
323 .StrideWidth(stride_rng())
324 .ReluMinus1To1Activation()
325 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
326 }
327
TEST(AveragePool2D,DISABLED_TanhActivation)328 TEST(AveragePool2D, DISABLED_TanhActivation) {
329 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
330 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
331 TfLiteXNNPackDelegateDelete);
332
333 std::random_device random_device;
334 auto rng = std::mt19937(random_device());
335 auto batch_rng =
336 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
337 auto input_rng =
338 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
339 auto pool_rng =
340 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
341 auto stride_rng =
342 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
343 auto channel_rng =
344 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
345
346 Pool2DTester()
347 .BatchSize(batch_rng())
348 .InputHeight(input_rng())
349 .InputWidth(input_rng())
350 .Channels(channel_rng())
351 .PoolingHeight(pool_rng())
352 .PoolingWidth(pool_rng())
353 .StrideHeight(stride_rng())
354 .StrideWidth(stride_rng())
355 .TanhActivation()
356 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
357 }
358
TEST(AveragePool2D,DISABLED_SignBitActivation)359 TEST(AveragePool2D, DISABLED_SignBitActivation) {
360 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
361 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
362 TfLiteXNNPackDelegateDelete);
363
364 std::random_device random_device;
365 auto rng = std::mt19937(random_device());
366 auto batch_rng =
367 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
368 auto input_rng =
369 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
370 auto pool_rng =
371 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
372 auto stride_rng =
373 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
374 auto channel_rng =
375 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
376
377 Pool2DTester()
378 .BatchSize(batch_rng())
379 .InputHeight(input_rng())
380 .InputWidth(input_rng())
381 .Channels(channel_rng())
382 .PoolingHeight(pool_rng())
383 .PoolingWidth(pool_rng())
384 .StrideHeight(stride_rng())
385 .StrideWidth(stride_rng())
386 .SignBitActivation()
387 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
388 }
389
TEST(AveragePool2D,MultiThreading)390 TEST(AveragePool2D, MultiThreading) {
391 TfLiteXNNPackDelegateOptions delegate_options =
392 TfLiteXNNPackDelegateOptionsDefault();
393 delegate_options.num_threads = 2;
394 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
395 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
396 TfLiteXNNPackDelegateDelete);
397
398 std::random_device random_device;
399 auto rng = std::mt19937(random_device());
400 auto batch_rng =
401 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
402 auto input_rng =
403 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
404 auto pool_rng =
405 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
406 auto stride_rng =
407 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
408 auto channel_rng =
409 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
410
411 Pool2DTester()
412 .BatchSize(batch_rng())
413 .InputHeight(input_rng())
414 .InputWidth(input_rng())
415 .Channels(channel_rng())
416 .PoolingHeight(pool_rng())
417 .PoolingWidth(pool_rng())
418 .StrideHeight(stride_rng())
419 .StrideWidth(stride_rng())
420 .Test(BuiltinOperator_AVERAGE_POOL_2D, xnnpack_delegate.get());
421 }
422
423 } // namespace xnnpack
424 } // namespace tflite
425