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