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