1 /* Copyright 2021 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/quantized_pool_2d_tester.h"
23 #include "tensorflow/lite/delegates/xnnpack/xnnpack_delegate.h"
24
25 namespace tflite {
26 namespace xnnpack {
27
TEST(UnsignedQuantizedMaxPool2D,UnitPoolSamePadding)28 TEST(UnsignedQuantizedMaxPool2D, 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 QuantizedPool2DTester()
43 .Unsigned(true)
44 .BatchSize(batch_rng())
45 .InputHeight(input_rng())
46 .InputWidth(input_rng())
47 .Channels(channel_rng())
48 .PoolingHeight(1)
49 .PoolingWidth(1)
50 .StrideHeight(1)
51 .StrideWidth(1)
52 .SamePadding()
53 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
54 }
55
TEST(UnsignedQuantizedMaxPool2D,UnitPoolValidPadding)56 TEST(UnsignedQuantizedMaxPool2D, UnitPoolValidPadding) {
57 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
58 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
59 TfLiteXNNPackDelegateDelete);
60
61 std::random_device random_device;
62 auto rng = std::mt19937(random_device());
63 auto batch_rng =
64 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
65 auto input_rng =
66 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
67 auto channel_rng =
68 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
69
70 QuantizedPool2DTester()
71 .Unsigned(true)
72 .BatchSize(batch_rng())
73 .InputHeight(input_rng())
74 .InputWidth(input_rng())
75 .Channels(channel_rng())
76 .PoolingHeight(1)
77 .PoolingWidth(1)
78 .StrideHeight(1)
79 .StrideWidth(1)
80 .ValidPadding()
81 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
82 }
83
TEST(UnsignedQuantizedMaxPool2D,EqualPoolAndStrideWithSamePadding)84 TEST(UnsignedQuantizedMaxPool2D, EqualPoolAndStrideWithSamePadding) {
85 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
86 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
87 TfLiteXNNPackDelegateDelete);
88
89 std::random_device random_device;
90 auto rng = std::mt19937(random_device());
91 auto batch_rng =
92 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
93 auto input_rng =
94 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
95 auto pool_rng =
96 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
97 auto channel_rng =
98 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
99
100 const int32_t pool_height = pool_rng();
101 const int32_t pool_width = pool_rng();
102
103 QuantizedPool2DTester()
104 .Unsigned(true)
105 .BatchSize(batch_rng())
106 .InputHeight(input_rng())
107 .InputWidth(input_rng())
108 .Channels(channel_rng())
109 .PoolingHeight(pool_height)
110 .PoolingWidth(pool_width)
111 .StrideHeight(pool_height)
112 .StrideWidth(pool_width)
113 .SamePadding()
114 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
115 }
116
TEST(UnsignedQuantizedMaxPool2D,EqualPoolAndStrideWithValidPadding)117 TEST(UnsignedQuantizedMaxPool2D, EqualPoolAndStrideWithValidPadding) {
118 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
119 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
120 TfLiteXNNPackDelegateDelete);
121
122 std::random_device random_device;
123 auto rng = std::mt19937(random_device());
124 auto batch_rng =
125 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
126 auto input_rng =
127 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
128 auto pool_rng =
129 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
130 auto channel_rng =
131 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
132
133 const int32_t pool_height = pool_rng();
134 const int32_t pool_width = pool_rng();
135
136 QuantizedPool2DTester()
137 .Unsigned(true)
138 .BatchSize(batch_rng())
139 .InputHeight(input_rng())
140 .InputWidth(input_rng())
141 .Channels(channel_rng())
142 .PoolingHeight(pool_height)
143 .PoolingWidth(pool_width)
144 .StrideHeight(pool_height)
145 .StrideWidth(pool_width)
146 .ValidPadding()
147 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
148 }
149
TEST(UnsignedQuantizedMaxPool2D,LargePoolSmallStrideWithSamePadding)150 TEST(UnsignedQuantizedMaxPool2D, LargePoolSmallStrideWithSamePadding) {
151 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
152 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
153 TfLiteXNNPackDelegateDelete);
154
155 std::random_device random_device;
156 auto rng = std::mt19937(random_device());
157 auto batch_rng =
158 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
159 auto input_rng =
160 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
161 auto pool_rng =
162 std::bind(std::uniform_int_distribution<int32_t>(4, 7), std::ref(rng));
163 auto stride_rng =
164 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
165 auto channel_rng =
166 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
167
168 QuantizedPool2DTester()
169 .Unsigned(true)
170 .BatchSize(batch_rng())
171 .InputHeight(input_rng())
172 .InputWidth(input_rng())
173 .Channels(channel_rng())
174 .PoolingHeight(pool_rng())
175 .PoolingWidth(pool_rng())
176 .StrideHeight(stride_rng())
177 .StrideWidth(stride_rng())
178 .SamePadding()
179 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
180 }
181
TEST(UnsignedQuantizedMaxPool2D,LargePoolSmallStrideWithValidPadding)182 TEST(UnsignedQuantizedMaxPool2D, LargePoolSmallStrideWithValidPadding) {
183 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
184 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
185 TfLiteXNNPackDelegateDelete);
186
187 std::random_device random_device;
188 auto rng = std::mt19937(random_device());
189 auto batch_rng =
190 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
191 auto input_rng =
192 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
193 auto pool_rng =
194 std::bind(std::uniform_int_distribution<int32_t>(4, 7), std::ref(rng));
195 auto stride_rng =
196 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
197 auto channel_rng =
198 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
199
200 QuantizedPool2DTester()
201 .Unsigned(true)
202 .BatchSize(batch_rng())
203 .InputHeight(input_rng())
204 .InputWidth(input_rng())
205 .Channels(channel_rng())
206 .PoolingHeight(pool_rng())
207 .PoolingWidth(pool_rng())
208 .StrideHeight(stride_rng())
209 .StrideWidth(stride_rng())
210 .ValidPadding()
211 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
212 }
213
TEST(UnsignedQuantizedMaxPool2D,GlobalPooling)214 TEST(UnsignedQuantizedMaxPool2D, GlobalPooling) {
215 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
216 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
217 TfLiteXNNPackDelegateDelete);
218
219 std::random_device random_device;
220 auto rng = std::mt19937(random_device());
221 auto batch_rng =
222 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
223 auto input_rng =
224 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
225 auto channel_rng =
226 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
227
228 const int32_t height = input_rng();
229 const int32_t width = input_rng();
230 QuantizedPool2DTester()
231 .Unsigned(true)
232 .BatchSize(batch_rng())
233 .InputHeight(height)
234 .InputWidth(width)
235 .Channels(channel_rng())
236 .PoolingHeight(height)
237 .PoolingWidth(width)
238 .ValidPadding()
239 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
240 }
241
TEST(UnsignedQuantizedMaxPool2D,ReluActivation)242 TEST(UnsignedQuantizedMaxPool2D, ReluActivation) {
243 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
244 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
245 TfLiteXNNPackDelegateDelete);
246
247 std::random_device random_device;
248 auto rng = std::mt19937(random_device());
249 auto batch_rng =
250 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
251 auto input_rng =
252 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
253 auto pool_rng =
254 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
255 auto stride_rng =
256 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
257 auto channel_rng =
258 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
259
260 QuantizedPool2DTester()
261 .Unsigned(true)
262 .BatchSize(batch_rng())
263 .InputHeight(input_rng())
264 .InputWidth(input_rng())
265 .Channels(channel_rng())
266 .PoolingHeight(pool_rng())
267 .PoolingWidth(pool_rng())
268 .StrideHeight(stride_rng())
269 .StrideWidth(stride_rng())
270 .ReluActivation()
271 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
272 }
273
TEST(UnsignedQuantizedMaxPool2D,Relu6Activation)274 TEST(UnsignedQuantizedMaxPool2D, Relu6Activation) {
275 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
276 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
277 TfLiteXNNPackDelegateDelete);
278
279 std::random_device random_device;
280 auto rng = std::mt19937(random_device());
281 auto batch_rng =
282 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
283 auto input_rng =
284 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
285 auto pool_rng =
286 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
287 auto stride_rng =
288 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
289 auto channel_rng =
290 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
291
292 QuantizedPool2DTester()
293 .Unsigned(true)
294 .BatchSize(batch_rng())
295 .InputHeight(input_rng())
296 .InputWidth(input_rng())
297 .Channels(channel_rng())
298 .PoolingHeight(pool_rng())
299 .PoolingWidth(pool_rng())
300 .StrideHeight(stride_rng())
301 .StrideWidth(stride_rng())
302 .Relu6Activation()
303 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
304 }
305
TEST(UnsignedQuantizedMaxPool2D,ReluMinus1To1Activation)306 TEST(UnsignedQuantizedMaxPool2D, ReluMinus1To1Activation) {
307 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
308 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
309 TfLiteXNNPackDelegateDelete);
310
311 std::random_device random_device;
312 auto rng = std::mt19937(random_device());
313 auto batch_rng =
314 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
315 auto input_rng =
316 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
317 auto pool_rng =
318 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
319 auto stride_rng =
320 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
321 auto channel_rng =
322 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
323
324 QuantizedPool2DTester()
325 .Unsigned(true)
326 .BatchSize(batch_rng())
327 .InputHeight(input_rng())
328 .InputWidth(input_rng())
329 .Channels(channel_rng())
330 .PoolingHeight(pool_rng())
331 .PoolingWidth(pool_rng())
332 .StrideHeight(stride_rng())
333 .StrideWidth(stride_rng())
334 .ReluMinus1To1Activation()
335 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
336 }
337
TEST(UnsignedQuantizedMaxPool2D,DISABLED_TanhActivation)338 TEST(UnsignedQuantizedMaxPool2D, DISABLED_TanhActivation) {
339 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
340 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
341 TfLiteXNNPackDelegateDelete);
342
343 std::random_device random_device;
344 auto rng = std::mt19937(random_device());
345 auto batch_rng =
346 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
347 auto input_rng =
348 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
349 auto pool_rng =
350 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
351 auto stride_rng =
352 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
353 auto channel_rng =
354 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
355
356 QuantizedPool2DTester()
357 .Unsigned(true)
358 .BatchSize(batch_rng())
359 .InputHeight(input_rng())
360 .InputWidth(input_rng())
361 .Channels(channel_rng())
362 .PoolingHeight(pool_rng())
363 .PoolingWidth(pool_rng())
364 .StrideHeight(stride_rng())
365 .StrideWidth(stride_rng())
366 .TanhActivation()
367 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
368 }
369
TEST(UnsignedQuantizedMaxPool2D,DISABLED_SignBitActivation)370 TEST(UnsignedQuantizedMaxPool2D, DISABLED_SignBitActivation) {
371 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
372 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
373 TfLiteXNNPackDelegateDelete);
374
375 std::random_device random_device;
376 auto rng = std::mt19937(random_device());
377 auto batch_rng =
378 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
379 auto input_rng =
380 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
381 auto pool_rng =
382 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
383 auto stride_rng =
384 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
385 auto channel_rng =
386 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
387
388 QuantizedPool2DTester()
389 .Unsigned(true)
390 .BatchSize(batch_rng())
391 .InputHeight(input_rng())
392 .InputWidth(input_rng())
393 .Channels(channel_rng())
394 .PoolingHeight(pool_rng())
395 .PoolingWidth(pool_rng())
396 .StrideHeight(stride_rng())
397 .StrideWidth(stride_rng())
398 .SignBitActivation()
399 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
400 }
401
TEST(UnsignedQuantizedMaxPool2D,MultiThreading)402 TEST(UnsignedQuantizedMaxPool2D, MultiThreading) {
403 TfLiteXNNPackDelegateOptions delegate_options =
404 TfLiteXNNPackDelegateOptionsDefault();
405 delegate_options.num_threads = 2;
406 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
407 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
408 TfLiteXNNPackDelegateDelete);
409
410 std::random_device random_device;
411 auto rng = std::mt19937(random_device());
412 auto batch_rng =
413 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
414 auto input_rng =
415 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
416 auto pool_rng =
417 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
418 auto stride_rng =
419 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
420 auto channel_rng =
421 std::bind(std::uniform_int_distribution<int32_t>(5, 16), std::ref(rng));
422
423 QuantizedPool2DTester()
424 .Unsigned(true)
425 .BatchSize(batch_rng())
426 .InputHeight(input_rng())
427 .InputWidth(input_rng())
428 .Channels(channel_rng())
429 .PoolingHeight(pool_rng())
430 .PoolingWidth(pool_rng())
431 .StrideHeight(stride_rng())
432 .StrideWidth(stride_rng())
433 .Test(BuiltinOperator_MAX_POOL_2D, xnnpack_delegate.get());
434 }
435
436 } // namespace xnnpack
437 } // namespace tflite
438