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 <limits>
19 #include <memory>
20 #include <random>
21
22 #include <gtest/gtest.h>
23 #include "tensorflow/lite/delegates/xnnpack/quantized_depthwise_conv_2d_tester.h"
24 #include "tensorflow/lite/delegates/xnnpack/xnnpack_delegate.h"
25
26 namespace tflite {
27 namespace xnnpack {
28
29 TEST(SignedQuantizedDepthwiseConv2D, 1x1) {
30 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
31 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
32 TfLiteXNNPackDelegateDelete);
33
34 std::random_device random_device;
35 auto rng = std::mt19937(random_device());
36 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
37 std::numeric_limits<int8_t>::min(),
38 std::numeric_limits<int8_t>::max()),
39 std::ref(rng));
40 auto input_rng =
41 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
42 auto channel_rng =
43 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
44
45 QuantizedDepthwiseConv2DTester()
46 .InputZeroPoint(zero_point_rng())
47 .OutputZeroPoint(zero_point_rng())
48 .InputHeight(input_rng())
49 .InputWidth(input_rng())
50 .InputChannels(channel_rng())
51 .KernelHeight(1)
52 .KernelWidth(1)
53 .Test(xnnpack_delegate.get());
54 }
55
56 TEST(SignedQuantizedDepthwiseConv2D, 2x2) {
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 zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
64 std::numeric_limits<int8_t>::min(),
65 std::numeric_limits<int8_t>::max()),
66 std::ref(rng));
67 auto input_rng =
68 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
69 auto channel_rng =
70 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
71
72 QuantizedDepthwiseConv2DTester()
73 .InputZeroPoint(zero_point_rng())
74 .OutputZeroPoint(zero_point_rng())
75 .InputHeight(input_rng())
76 .InputWidth(input_rng())
77 .InputChannels(channel_rng())
78 .KernelHeight(2)
79 .KernelWidth(2)
80 .SamePadding()
81 .Test(xnnpack_delegate.get());
82 }
83
84 TEST(SignedQuantizedDepthwiseConv2D, 3x3) {
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 zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
92 std::numeric_limits<int8_t>::min(),
93 std::numeric_limits<int8_t>::max()),
94 std::ref(rng));
95 auto input_rng =
96 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
97 auto channel_rng =
98 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
99
100 QuantizedDepthwiseConv2DTester()
101 .InputZeroPoint(zero_point_rng())
102 .OutputZeroPoint(zero_point_rng())
103 .InputHeight(input_rng())
104 .InputWidth(input_rng())
105 .InputChannels(channel_rng())
106 .KernelHeight(3)
107 .KernelWidth(3)
108 .SamePadding()
109 .Test(xnnpack_delegate.get());
110 }
111
112 TEST(SignedQuantizedDepthwiseConv2D, 3x3Stride2) {
113 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
114 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
115 TfLiteXNNPackDelegateDelete);
116
117 std::random_device random_device;
118 auto rng = std::mt19937(random_device());
119 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
120 std::numeric_limits<int8_t>::min(),
121 std::numeric_limits<int8_t>::max()),
122 std::ref(rng));
123 auto input_rng =
124 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
125 auto channel_rng =
126 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
127
128 QuantizedDepthwiseConv2DTester()
129 .InputZeroPoint(zero_point_rng())
130 .OutputZeroPoint(zero_point_rng())
131 .InputHeight(input_rng())
132 .InputWidth(input_rng())
133 .InputChannels(channel_rng())
134 .KernelHeight(3)
135 .KernelWidth(3)
136 .StrideHeight(2)
137 .StrideWidth(2)
138 .SamePadding()
139 .Test(xnnpack_delegate.get());
140 }
141
142 TEST(SignedQuantizedDepthwiseConv2D, 5x5) {
143 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
144 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
145 TfLiteXNNPackDelegateDelete);
146
147 std::random_device random_device;
148 auto rng = std::mt19937(random_device());
149 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
150 std::numeric_limits<int8_t>::min(),
151 std::numeric_limits<int8_t>::max()),
152 std::ref(rng));
153 auto input_rng =
154 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
155 auto channel_rng =
156 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
157
158 QuantizedDepthwiseConv2DTester()
159 .InputZeroPoint(zero_point_rng())
160 .OutputZeroPoint(zero_point_rng())
161 .InputHeight(input_rng())
162 .InputWidth(input_rng())
163 .InputChannels(channel_rng())
164 .KernelHeight(3)
165 .KernelWidth(3)
166 .SamePadding()
167 .Test(xnnpack_delegate.get());
168 }
169
170 TEST(SignedQuantizedDepthwiseConv2D, 5x5Stride2) {
171 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
172 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
173 TfLiteXNNPackDelegateDelete);
174
175 std::random_device random_device;
176 auto rng = std::mt19937(random_device());
177 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
178 std::numeric_limits<int8_t>::min(),
179 std::numeric_limits<int8_t>::max()),
180 std::ref(rng));
181 auto input_rng =
182 std::bind(std::uniform_int_distribution<int32_t>(5, 25), std::ref(rng));
183 auto channel_rng =
184 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
185
186 QuantizedDepthwiseConv2DTester()
187 .InputZeroPoint(zero_point_rng())
188 .OutputZeroPoint(zero_point_rng())
189 .InputHeight(input_rng())
190 .InputWidth(input_rng())
191 .InputChannels(channel_rng())
192 .KernelHeight(3)
193 .KernelWidth(3)
194 .StrideHeight(2)
195 .StrideWidth(2)
196 .SamePadding()
197 .Test(xnnpack_delegate.get());
198 }
199
TEST(SignedQuantizedDepthwiseConv2D,SmallKernelWithSamePadding)200 TEST(SignedQuantizedDepthwiseConv2D, SmallKernelWithSamePadding) {
201 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
202 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
203 TfLiteXNNPackDelegateDelete);
204
205 std::random_device random_device;
206 auto rng = std::mt19937(random_device());
207 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
208 std::numeric_limits<int8_t>::min(),
209 std::numeric_limits<int8_t>::max()),
210 std::ref(rng));
211 auto batch_rng =
212 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
213 auto input_rng =
214 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
215 auto kernel_rng =
216 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
217 auto channel_rng =
218 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
219
220 QuantizedDepthwiseConv2DTester()
221 .InputZeroPoint(zero_point_rng())
222 .OutputZeroPoint(zero_point_rng())
223 .BatchSize(batch_rng())
224 .InputHeight(input_rng())
225 .InputWidth(input_rng())
226 .InputChannels(channel_rng())
227 .KernelHeight(kernel_rng())
228 .KernelWidth(kernel_rng())
229 .SamePadding()
230 .Test(xnnpack_delegate.get());
231 }
232
TEST(SignedQuantizedDepthwiseConv2D,SmallKernelWithValidPadding)233 TEST(SignedQuantizedDepthwiseConv2D, SmallKernelWithValidPadding) {
234 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
235 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
236 TfLiteXNNPackDelegateDelete);
237
238 std::random_device random_device;
239 auto rng = std::mt19937(random_device());
240 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
241 std::numeric_limits<int8_t>::min(),
242 std::numeric_limits<int8_t>::max()),
243 std::ref(rng));
244 auto batch_rng =
245 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
246 auto input_rng =
247 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
248 auto kernel_rng =
249 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
250 auto channel_rng =
251 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
252
253 QuantizedDepthwiseConv2DTester()
254 .InputZeroPoint(zero_point_rng())
255 .OutputZeroPoint(zero_point_rng())
256 .BatchSize(batch_rng())
257 .InputHeight(input_rng())
258 .InputWidth(input_rng())
259 .InputChannels(channel_rng())
260 .KernelHeight(kernel_rng())
261 .KernelWidth(kernel_rng())
262 .ValidPadding()
263 .Test(xnnpack_delegate.get());
264 }
265
TEST(SignedQuantizedDepthwiseConv2D,StrideWithSamePadding)266 TEST(SignedQuantizedDepthwiseConv2D, StrideWithSamePadding) {
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 zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
274 std::numeric_limits<int8_t>::min(),
275 std::numeric_limits<int8_t>::max()),
276 std::ref(rng));
277 auto batch_rng =
278 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
279 auto input_rng =
280 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
281 auto kernel_rng =
282 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
283 auto stride_rng =
284 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
285 auto channel_rng =
286 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
287
288 QuantizedDepthwiseConv2DTester()
289 .InputZeroPoint(zero_point_rng())
290 .OutputZeroPoint(zero_point_rng())
291 .BatchSize(batch_rng())
292 .InputHeight(input_rng())
293 .InputWidth(input_rng())
294 .InputChannels(channel_rng())
295 .KernelHeight(kernel_rng())
296 .KernelWidth(kernel_rng())
297 .StrideHeight(stride_rng())
298 .StrideWidth(stride_rng())
299 .SamePadding()
300 .Test(xnnpack_delegate.get());
301 }
302
TEST(SignedQuantizedDepthwiseConv2D,StrideWithValidPadding)303 TEST(SignedQuantizedDepthwiseConv2D, StrideWithValidPadding) {
304 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
305 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
306 TfLiteXNNPackDelegateDelete);
307
308 std::random_device random_device;
309 auto rng = std::mt19937(random_device());
310 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
311 std::numeric_limits<int8_t>::min(),
312 std::numeric_limits<int8_t>::max()),
313 std::ref(rng));
314 auto batch_rng =
315 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
316 auto input_rng =
317 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
318 auto kernel_rng =
319 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
320 auto stride_rng =
321 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
322 auto channel_rng =
323 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
324
325 QuantizedDepthwiseConv2DTester()
326 .InputZeroPoint(zero_point_rng())
327 .OutputZeroPoint(zero_point_rng())
328 .BatchSize(batch_rng())
329 .InputHeight(input_rng())
330 .InputWidth(input_rng())
331 .InputChannels(channel_rng())
332 .KernelHeight(kernel_rng())
333 .KernelWidth(kernel_rng())
334 .StrideHeight(stride_rng())
335 .StrideWidth(stride_rng())
336 .ValidPadding()
337 .Test(xnnpack_delegate.get());
338 }
339
TEST(SignedQuantizedDepthwiseConv2D,DilationWithSamePadding)340 TEST(SignedQuantizedDepthwiseConv2D, DilationWithSamePadding) {
341 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
342 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
343 TfLiteXNNPackDelegateDelete);
344
345 std::random_device random_device;
346 auto rng = std::mt19937(random_device());
347 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
348 std::numeric_limits<int8_t>::min(),
349 std::numeric_limits<int8_t>::max()),
350 std::ref(rng));
351 auto batch_rng =
352 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
353 auto input_rng =
354 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
355 auto kernel_rng =
356 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
357 auto dilation_rng =
358 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
359 auto channel_rng =
360 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
361
362 QuantizedDepthwiseConv2DTester()
363 .InputZeroPoint(zero_point_rng())
364 .OutputZeroPoint(zero_point_rng())
365 .BatchSize(batch_rng())
366 .InputHeight(input_rng())
367 .InputWidth(input_rng())
368 .InputChannels(channel_rng())
369 .KernelHeight(kernel_rng())
370 .KernelWidth(kernel_rng())
371 .DilationHeight(dilation_rng())
372 .DilationWidth(dilation_rng())
373 .SamePadding()
374 .Test(xnnpack_delegate.get());
375 }
376
TEST(SignedQuantizedDepthwiseConv2D,DilationWithValidPadding)377 TEST(SignedQuantizedDepthwiseConv2D, DilationWithValidPadding) {
378 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
379 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
380 TfLiteXNNPackDelegateDelete);
381
382 std::random_device random_device;
383 auto rng = std::mt19937(random_device());
384 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
385 std::numeric_limits<int8_t>::min(),
386 std::numeric_limits<int8_t>::max()),
387 std::ref(rng));
388 auto batch_rng =
389 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
390 auto input_rng =
391 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
392 auto kernel_rng =
393 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
394 auto dilation_rng =
395 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
396 auto channel_rng =
397 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
398
399 QuantizedDepthwiseConv2DTester()
400 .InputZeroPoint(zero_point_rng())
401 .OutputZeroPoint(zero_point_rng())
402 .BatchSize(batch_rng())
403 .InputHeight(input_rng())
404 .InputWidth(input_rng())
405 .InputChannels(channel_rng())
406 .KernelHeight(kernel_rng())
407 .KernelWidth(kernel_rng())
408 .DilationHeight(dilation_rng())
409 .DilationWidth(dilation_rng())
410 .ValidPadding()
411 .Test(xnnpack_delegate.get());
412 }
413
TEST(SignedQuantizedDepthwiseConv2D,DepthMultiplier)414 TEST(SignedQuantizedDepthwiseConv2D, DepthMultiplier) {
415 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
416 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
417 TfLiteXNNPackDelegateDelete);
418
419 std::random_device random_device;
420 auto rng = std::mt19937(random_device());
421 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
422 std::numeric_limits<int8_t>::min(),
423 std::numeric_limits<int8_t>::max()),
424 std::ref(rng));
425 auto batch_rng =
426 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
427 auto input_rng =
428 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
429 auto kernel_rng =
430 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
431 auto stride_rng =
432 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
433 auto channel_rng =
434 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
435 auto multiplier_rng =
436 std::bind(std::uniform_int_distribution<int32_t>(2, 8), std::ref(rng));
437
438 QuantizedDepthwiseConv2DTester()
439 .InputZeroPoint(zero_point_rng())
440 .OutputZeroPoint(zero_point_rng())
441 .BatchSize(batch_rng())
442 .InputHeight(input_rng())
443 .InputWidth(input_rng())
444 .InputChannels(channel_rng())
445 .KernelHeight(kernel_rng())
446 .KernelWidth(kernel_rng())
447 .StrideHeight(stride_rng())
448 .StrideWidth(stride_rng())
449 .DepthMultiplier(multiplier_rng())
450 .Test(xnnpack_delegate.get());
451 }
452
TEST(SignedQuantizedDepthwiseConv2D,ReluActivation)453 TEST(SignedQuantizedDepthwiseConv2D, ReluActivation) {
454 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
455 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
456 TfLiteXNNPackDelegateDelete);
457
458 std::random_device random_device;
459 auto rng = std::mt19937(random_device());
460 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
461 std::numeric_limits<int8_t>::min(),
462 std::numeric_limits<int8_t>::max()),
463 std::ref(rng));
464 auto batch_rng =
465 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
466 auto input_rng =
467 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
468 auto kernel_rng =
469 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
470 auto stride_rng =
471 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
472 auto channel_rng =
473 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
474
475 QuantizedDepthwiseConv2DTester()
476 .InputZeroPoint(zero_point_rng())
477 .OutputZeroPoint(0)
478 .BatchSize(batch_rng())
479 .InputHeight(input_rng())
480 .InputWidth(input_rng())
481 .InputChannels(channel_rng())
482 .KernelHeight(kernel_rng())
483 .KernelWidth(kernel_rng())
484 .StrideHeight(stride_rng())
485 .StrideWidth(stride_rng())
486 .ReluActivation()
487 .Test(xnnpack_delegate.get());
488 }
489
TEST(SignedQuantizedDepthwiseConv2D,Relu6Activation)490 TEST(SignedQuantizedDepthwiseConv2D, Relu6Activation) {
491 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
492 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
493 TfLiteXNNPackDelegateDelete);
494
495 std::random_device random_device;
496 auto rng = std::mt19937(random_device());
497 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
498 std::numeric_limits<int8_t>::min(),
499 std::numeric_limits<int8_t>::max()),
500 std::ref(rng));
501 auto batch_rng =
502 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
503 auto input_rng =
504 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
505 auto kernel_rng =
506 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
507 auto stride_rng =
508 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
509 auto channel_rng =
510 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
511
512 QuantizedDepthwiseConv2DTester()
513 .InputZeroPoint(zero_point_rng())
514 .OutputZeroPoint(0)
515 .BatchSize(batch_rng())
516 .InputHeight(input_rng())
517 .InputWidth(input_rng())
518 .InputChannels(channel_rng())
519 .KernelHeight(kernel_rng())
520 .KernelWidth(kernel_rng())
521 .StrideHeight(stride_rng())
522 .StrideWidth(stride_rng())
523 .Relu6Activation()
524 .Test(xnnpack_delegate.get());
525 }
526
TEST(SignedQuantizedDepthwiseConv2D,ReluMinus1To1Activation)527 TEST(SignedQuantizedDepthwiseConv2D, ReluMinus1To1Activation) {
528 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
529 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
530 TfLiteXNNPackDelegateDelete);
531
532 std::random_device random_device;
533 auto rng = std::mt19937(random_device());
534 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
535 std::numeric_limits<int8_t>::min(),
536 std::numeric_limits<int8_t>::max()),
537 std::ref(rng));
538 auto batch_rng =
539 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
540 auto input_rng =
541 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
542 auto kernel_rng =
543 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
544 auto stride_rng =
545 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
546 auto channel_rng =
547 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
548
549 QuantizedDepthwiseConv2DTester()
550 .InputZeroPoint(zero_point_rng())
551 .OutputZeroPoint(zero_point_rng())
552 .BatchSize(batch_rng())
553 .InputHeight(input_rng())
554 .InputWidth(input_rng())
555 .InputChannels(channel_rng())
556 .KernelHeight(kernel_rng())
557 .KernelWidth(kernel_rng())
558 .StrideHeight(stride_rng())
559 .StrideWidth(stride_rng())
560 .ReluMinus1To1Activation()
561 .Test(xnnpack_delegate.get());
562 }
563
TEST(SignedQuantizedDepthwiseConv2D,MultiThreading)564 TEST(SignedQuantizedDepthwiseConv2D, MultiThreading) {
565 TfLiteXNNPackDelegateOptions delegate_options =
566 TfLiteXNNPackDelegateOptionsDefault();
567 delegate_options.num_threads = 2;
568 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
569 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
570 TfLiteXNNPackDelegateDelete);
571
572 std::random_device random_device;
573 auto rng = std::mt19937(random_device());
574 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
575 std::numeric_limits<int8_t>::min(),
576 std::numeric_limits<int8_t>::max()),
577 std::ref(rng));
578 auto batch_rng =
579 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
580 auto input_rng =
581 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
582 auto kernel_rng =
583 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
584 auto stride_rng =
585 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
586 auto channel_rng =
587 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
588
589 QuantizedDepthwiseConv2DTester()
590 .InputZeroPoint(zero_point_rng())
591 .OutputZeroPoint(zero_point_rng())
592 .BatchSize(batch_rng())
593 .InputHeight(input_rng())
594 .InputWidth(input_rng())
595 .InputChannels(channel_rng())
596 .KernelHeight(kernel_rng())
597 .KernelWidth(kernel_rng())
598 .StrideHeight(stride_rng())
599 .StrideWidth(stride_rng())
600 .Test(xnnpack_delegate.get());
601 }
602
TEST(SignedQuantizedDepthwiseConv2D,WeightsCache)603 TEST(SignedQuantizedDepthwiseConv2D, WeightsCache) {
604 TfLiteXNNPackDelegateOptions delegate_options =
605 TfLiteXNNPackDelegateOptionsDefault();
606 std::unique_ptr<TfLiteXNNPackDelegateWeightsCache,
607 decltype(&TfLiteXNNPackDelegateWeightsCacheDelete)>
608 weights_cache(TfLiteXNNPackDelegateWeightsCacheCreate(),
609 TfLiteXNNPackDelegateWeightsCacheDelete);
610 delegate_options.weights_cache = weights_cache.get();
611 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
612 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
613 TfLiteXNNPackDelegateDelete);
614
615 std::random_device random_device;
616 auto rng = std::mt19937(random_device());
617 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
618 std::numeric_limits<int8_t>::min(),
619 std::numeric_limits<int8_t>::max()),
620 std::ref(rng));
621 auto batch_rng =
622 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
623 auto input_rng =
624 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
625 auto kernel_rng =
626 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
627 auto stride_rng =
628 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
629 auto channel_rng =
630 std::bind(std::uniform_int_distribution<int32_t>(3, 32), std::ref(rng));
631
632 QuantizedDepthwiseConv2DTester()
633 .InputZeroPoint(zero_point_rng())
634 .OutputZeroPoint(zero_point_rng())
635 .BatchSize(batch_rng())
636 .InputHeight(input_rng())
637 .InputWidth(input_rng())
638 .InputChannels(channel_rng())
639 .KernelHeight(kernel_rng())
640 .KernelWidth(kernel_rng())
641 .StrideHeight(stride_rng())
642 .StrideWidth(stride_rng())
643 .WeightsCache(weights_cache.get())
644 .Test(xnnpack_delegate.get());
645 }
646
647 } // namespace xnnpack
648 } // namespace tflite
649