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,Grouped)108 TEST(Conv2D, Grouped) {
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>(5, 25), std::ref(rng));
119 auto channel_per_group_rng =
120 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
121 auto groups_rng =
122 std::bind(std::uniform_int_distribution<int32_t>(2, 8), std::ref(rng));
123
124 auto groups = groups_rng();
125 Conv2DTester()
126 .BatchSize(batch_rng())
127 .InputHeight(input_rng())
128 .InputWidth(input_rng())
129 .InputChannels(groups * channel_per_group_rng())
130 .OutputChannels(groups * channel_per_group_rng())
131 .Groups(groups)
132 .KernelHeight(3)
133 .KernelWidth(3)
134 .SamePadding()
135 .Test(xnnpack_delegate.get());
136 }
137
TEST(Conv2D,SmallKernelWithSamePadding)138 TEST(Conv2D, SmallKernelWithSamePadding) {
139 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
140 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
141 TfLiteXNNPackDelegateDelete);
142
143 std::random_device random_device;
144 auto rng = std::mt19937(random_device());
145 auto batch_rng =
146 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
147 auto input_rng =
148 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
149 auto kernel_rng =
150 std::bind(std::uniform_int_distribution<int32_t>(2, 7), std::ref(rng));
151 auto channel_rng =
152 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
153
154 Conv2DTester()
155 .BatchSize(batch_rng())
156 .InputHeight(input_rng())
157 .InputWidth(input_rng())
158 .InputChannels(channel_rng())
159 .OutputChannels(channel_rng())
160 .KernelHeight(kernel_rng())
161 .KernelWidth(kernel_rng())
162 .SamePadding()
163 .Test(xnnpack_delegate.get());
164 }
165
TEST(Conv2D,SmallKernelWithValidPadding)166 TEST(Conv2D, SmallKernelWithValidPadding) {
167 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
168 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
169 TfLiteXNNPackDelegateDelete);
170
171 std::random_device random_device;
172 auto rng = std::mt19937(random_device());
173 auto batch_rng =
174 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
175 auto input_rng =
176 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
177 auto kernel_rng =
178 std::bind(std::uniform_int_distribution<int32_t>(2, 7), 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 .ValidPadding()
191 .Test(xnnpack_delegate.get());
192 }
193
TEST(Conv2D,StrideWithSamePadding)194 TEST(Conv2D, StrideWithSamePadding) {
195 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
196 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
197 TfLiteXNNPackDelegateDelete);
198
199 std::random_device random_device;
200 auto rng = std::mt19937(random_device());
201 auto batch_rng =
202 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
203 auto input_rng =
204 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
205 auto kernel_rng =
206 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
207 auto stride_rng =
208 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
209 auto channel_rng =
210 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
211
212 Conv2DTester()
213 .BatchSize(batch_rng())
214 .InputHeight(input_rng())
215 .InputWidth(input_rng())
216 .InputChannels(channel_rng())
217 .OutputChannels(channel_rng())
218 .KernelHeight(kernel_rng())
219 .KernelWidth(kernel_rng())
220 .StrideHeight(stride_rng())
221 .StrideWidth(stride_rng())
222 .SamePadding()
223 .Test(xnnpack_delegate.get());
224 }
225
TEST(Conv2D,StrideWithValidPadding)226 TEST(Conv2D, StrideWithValidPadding) {
227 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
228 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
229 TfLiteXNNPackDelegateDelete);
230
231 std::random_device random_device;
232 auto rng = std::mt19937(random_device());
233 auto batch_rng =
234 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
235 auto input_rng =
236 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
237 auto kernel_rng =
238 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
239 auto stride_rng =
240 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
241 auto channel_rng =
242 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
243
244 Conv2DTester()
245 .BatchSize(batch_rng())
246 .InputHeight(input_rng())
247 .InputWidth(input_rng())
248 .InputChannels(channel_rng())
249 .OutputChannels(channel_rng())
250 .KernelHeight(kernel_rng())
251 .KernelWidth(kernel_rng())
252 .StrideHeight(stride_rng())
253 .StrideWidth(stride_rng())
254 .ValidPadding()
255 .Test(xnnpack_delegate.get());
256 }
257
TEST(Conv2D,DilationWithSamePadding)258 TEST(Conv2D, DilationWithSamePadding) {
259 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
260 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
261 TfLiteXNNPackDelegateDelete);
262
263 std::random_device random_device;
264 auto rng = std::mt19937(random_device());
265 auto batch_rng =
266 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
267 auto input_rng =
268 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
269 auto kernel_rng =
270 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
271 auto dilation_rng =
272 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
273 auto channel_rng =
274 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
275
276 Conv2DTester()
277 .BatchSize(batch_rng())
278 .InputHeight(input_rng())
279 .InputWidth(input_rng())
280 .InputChannels(channel_rng())
281 .OutputChannels(channel_rng())
282 .KernelHeight(kernel_rng())
283 .KernelWidth(kernel_rng())
284 .DilationHeight(dilation_rng())
285 .DilationWidth(dilation_rng())
286 .SamePadding()
287 .Test(xnnpack_delegate.get());
288 }
289
TEST(Conv2D,DilationWithValidPadding)290 TEST(Conv2D, DilationWithValidPadding) {
291 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
292 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
293 TfLiteXNNPackDelegateDelete);
294
295 std::random_device random_device;
296 auto rng = std::mt19937(random_device());
297 auto batch_rng =
298 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
299 auto input_rng =
300 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
301 auto kernel_rng =
302 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
303 auto dilation_rng =
304 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
305 auto channel_rng =
306 std::bind(std::uniform_int_distribution<int32_t>(2, 16), std::ref(rng));
307
308 Conv2DTester()
309 .BatchSize(batch_rng())
310 .InputHeight(input_rng())
311 .InputWidth(input_rng())
312 .InputChannels(channel_rng())
313 .OutputChannels(channel_rng())
314 .KernelHeight(kernel_rng())
315 .KernelWidth(kernel_rng())
316 .DilationHeight(dilation_rng())
317 .DilationWidth(dilation_rng())
318 .ValidPadding()
319 .Test(xnnpack_delegate.get());
320 }
321
TEST(Conv2D,FP16Weights)322 TEST(Conv2D, FP16Weights) {
323 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
324 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
325 TfLiteXNNPackDelegateDelete);
326
327 std::random_device random_device;
328 auto rng = std::mt19937(random_device());
329 auto batch_rng =
330 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
331 auto input_rng =
332 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
333 auto kernel_rng =
334 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
335 auto stride_rng =
336 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
337 auto channel_rng =
338 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
339
340 Conv2DTester()
341 .BatchSize(batch_rng())
342 .InputHeight(input_rng())
343 .InputWidth(input_rng())
344 .InputChannels(channel_rng())
345 .OutputChannels(channel_rng())
346 .KernelHeight(kernel_rng())
347 .KernelWidth(kernel_rng())
348 .StrideHeight(stride_rng())
349 .StrideWidth(stride_rng())
350 .FP16Weights()
351 .Test(xnnpack_delegate.get());
352 }
353
TEST(Conv2D,INT8Weights)354 TEST(Conv2D, INT8Weights) {
355 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
356 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
357 TfLiteXNNPackDelegateDelete);
358
359 std::random_device random_device;
360 auto rng = std::mt19937(random_device());
361 auto batch_rng =
362 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
363 auto input_rng =
364 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
365 auto kernel_rng =
366 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
367 auto stride_rng =
368 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
369 auto channel_rng =
370 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
371
372 Conv2DTester()
373 .BatchSize(batch_rng())
374 .InputHeight(input_rng())
375 .InputWidth(input_rng())
376 .InputChannels(channel_rng())
377 .OutputChannels(channel_rng())
378 .KernelHeight(kernel_rng())
379 .KernelWidth(kernel_rng())
380 .StrideHeight(stride_rng())
381 .StrideWidth(stride_rng())
382 .INT8Weights()
383 .Test(xnnpack_delegate.get());
384 }
385
TEST(Conv2D,INT8ChannelWiseWeights)386 TEST(Conv2D, INT8ChannelWiseWeights) {
387 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
388 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
389 TfLiteXNNPackDelegateDelete);
390
391 std::random_device random_device;
392 auto rng = std::mt19937(random_device());
393 auto batch_rng =
394 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
395 auto input_rng =
396 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
397 auto kernel_rng =
398 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
399 auto stride_rng =
400 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
401 auto channel_rng =
402 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
403
404 Conv2DTester()
405 .BatchSize(batch_rng())
406 .InputHeight(input_rng())
407 .InputWidth(input_rng())
408 .InputChannels(channel_rng())
409 .OutputChannels(channel_rng())
410 .KernelHeight(kernel_rng())
411 .KernelWidth(kernel_rng())
412 .StrideHeight(stride_rng())
413 .StrideWidth(stride_rng())
414 .INT8ChannelWiseWeights()
415 .Test(xnnpack_delegate.get());
416 }
417
TEST(Conv2D,SparseWeights)418 TEST(Conv2D, SparseWeights) {
419 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
420 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
421 TfLiteXNNPackDelegateDelete);
422
423 std::random_device random_device;
424 auto rng = std::mt19937(random_device());
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>(1, 16), std::ref(rng));
435
436 Conv2DTester()
437 .BatchSize(batch_rng())
438 .InputHeight(input_rng())
439 .InputWidth(input_rng())
440 .InputChannels(channel_rng())
441 .OutputChannels(channel_rng())
442 .KernelHeight(kernel_rng())
443 .KernelWidth(kernel_rng())
444 .StrideHeight(stride_rng())
445 .StrideWidth(stride_rng())
446 .SparseWeights()
447 .Test(xnnpack_delegate.get());
448 }
449
TEST(Conv2D,SparseFP16Weights)450 TEST(Conv2D, SparseFP16Weights) {
451 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
452 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
453 TfLiteXNNPackDelegateDelete);
454
455 std::random_device random_device;
456 auto rng = std::mt19937(random_device());
457 auto batch_rng =
458 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
459 auto input_rng =
460 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
461 auto kernel_rng =
462 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
463 auto stride_rng =
464 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
465 auto channel_rng =
466 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
467
468 Conv2DTester()
469 .BatchSize(batch_rng())
470 .InputHeight(input_rng())
471 .InputWidth(input_rng())
472 .InputChannels(channel_rng())
473 .OutputChannels(channel_rng())
474 .KernelHeight(kernel_rng())
475 .KernelWidth(kernel_rng())
476 .StrideHeight(stride_rng())
477 .StrideWidth(stride_rng())
478 .SparseWeights()
479 .FP16Weights()
480 .Test(xnnpack_delegate.get());
481 }
482
TEST(Conv2D,SparseINT8Weights)483 TEST(Conv2D, SparseINT8Weights) {
484 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
485 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
486 TfLiteXNNPackDelegateDelete);
487
488 std::random_device random_device;
489 auto rng = std::mt19937(random_device());
490 auto batch_rng =
491 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
492 auto input_rng =
493 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
494 auto kernel_rng =
495 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
496 auto stride_rng =
497 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
498 auto channel_rng =
499 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
500
501 Conv2DTester()
502 .BatchSize(batch_rng())
503 .InputHeight(input_rng())
504 .InputWidth(input_rng())
505 .InputChannels(channel_rng())
506 .OutputChannels(channel_rng())
507 .KernelHeight(kernel_rng())
508 .KernelWidth(kernel_rng())
509 .StrideHeight(stride_rng())
510 .StrideWidth(stride_rng())
511 .SparseWeights()
512 .INT8Weights()
513 .Test(xnnpack_delegate.get());
514 }
515
TEST(Conv2D,SparseINT8ChannelWiseWeights)516 TEST(Conv2D, SparseINT8ChannelWiseWeights) {
517 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
518 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
519 TfLiteXNNPackDelegateDelete);
520
521 std::random_device random_device;
522 auto rng = std::mt19937(random_device());
523 auto batch_rng =
524 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
525 auto input_rng =
526 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
527 auto kernel_rng =
528 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
529 auto stride_rng =
530 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
531 auto channel_rng =
532 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
533
534 Conv2DTester()
535 .BatchSize(batch_rng())
536 .InputHeight(input_rng())
537 .InputWidth(input_rng())
538 .InputChannels(channel_rng())
539 .OutputChannels(channel_rng())
540 .KernelHeight(kernel_rng())
541 .KernelWidth(kernel_rng())
542 .StrideHeight(stride_rng())
543 .StrideWidth(stride_rng())
544 .SparseWeights()
545 .INT8ChannelWiseWeights()
546 .Test(xnnpack_delegate.get());
547 }
548
TEST(Conv2D,ReluActivation)549 TEST(Conv2D, ReluActivation) {
550 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
551 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
552 TfLiteXNNPackDelegateDelete);
553
554 std::random_device random_device;
555 auto rng = std::mt19937(random_device());
556 auto batch_rng =
557 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
558 auto input_rng =
559 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
560 auto kernel_rng =
561 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
562 auto stride_rng =
563 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
564 auto channel_rng =
565 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
566
567 Conv2DTester()
568 .BatchSize(batch_rng())
569 .InputHeight(input_rng())
570 .InputWidth(input_rng())
571 .InputChannels(channel_rng())
572 .OutputChannels(channel_rng())
573 .KernelHeight(kernel_rng())
574 .KernelWidth(kernel_rng())
575 .StrideHeight(stride_rng())
576 .StrideWidth(stride_rng())
577 .ReluActivation()
578 .Test(xnnpack_delegate.get());
579 }
580
TEST(Conv2D,Relu6Activation)581 TEST(Conv2D, Relu6Activation) {
582 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
583 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
584 TfLiteXNNPackDelegateDelete);
585
586 std::random_device random_device;
587 auto rng = std::mt19937(random_device());
588 auto batch_rng =
589 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
590 auto input_rng =
591 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
592 auto kernel_rng =
593 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
594 auto stride_rng =
595 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
596 auto channel_rng =
597 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
598
599 Conv2DTester()
600 .BatchSize(batch_rng())
601 .InputHeight(input_rng())
602 .InputWidth(input_rng())
603 .InputChannels(channel_rng())
604 .OutputChannels(channel_rng())
605 .KernelHeight(kernel_rng())
606 .KernelWidth(kernel_rng())
607 .StrideHeight(stride_rng())
608 .StrideWidth(stride_rng())
609 .Relu6Activation()
610 .Test(xnnpack_delegate.get());
611 }
612
TEST(Conv2D,ReluMinus1To1Activation)613 TEST(Conv2D, ReluMinus1To1Activation) {
614 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
615 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
616 TfLiteXNNPackDelegateDelete);
617
618 std::random_device random_device;
619 auto rng = std::mt19937(random_device());
620 auto batch_rng =
621 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
622 auto input_rng =
623 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
624 auto kernel_rng =
625 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
626 auto stride_rng =
627 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
628 auto channel_rng =
629 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
630
631 Conv2DTester()
632 .BatchSize(batch_rng())
633 .InputHeight(input_rng())
634 .InputWidth(input_rng())
635 .InputChannels(channel_rng())
636 .OutputChannels(channel_rng())
637 .KernelHeight(kernel_rng())
638 .KernelWidth(kernel_rng())
639 .StrideHeight(stride_rng())
640 .StrideWidth(stride_rng())
641 .ReluMinus1To1Activation()
642 .Test(xnnpack_delegate.get());
643 }
644
TEST(Conv2D,DISABLED_TanhActivation)645 TEST(Conv2D, DISABLED_TanhActivation) {
646 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
647 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
648 TfLiteXNNPackDelegateDelete);
649
650 std::random_device random_device;
651 auto rng = std::mt19937(random_device());
652 auto batch_rng =
653 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
654 auto input_rng =
655 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
656 auto kernel_rng =
657 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
658 auto stride_rng =
659 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
660 auto channel_rng =
661 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
662
663 Conv2DTester()
664 .BatchSize(batch_rng())
665 .InputHeight(input_rng())
666 .InputWidth(input_rng())
667 .InputChannels(channel_rng())
668 .OutputChannels(channel_rng())
669 .KernelHeight(kernel_rng())
670 .KernelWidth(kernel_rng())
671 .StrideHeight(stride_rng())
672 .StrideWidth(stride_rng())
673 .TanhActivation()
674 .Test(xnnpack_delegate.get());
675 }
676
TEST(Conv2D,DISABLED_SignBitActivation)677 TEST(Conv2D, DISABLED_SignBitActivation) {
678 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
679 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
680 TfLiteXNNPackDelegateDelete);
681
682 std::random_device random_device;
683 auto rng = std::mt19937(random_device());
684 auto batch_rng =
685 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
686 auto input_rng =
687 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
688 auto kernel_rng =
689 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
690 auto stride_rng =
691 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
692 auto channel_rng =
693 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
694
695 Conv2DTester()
696 .BatchSize(batch_rng())
697 .InputHeight(input_rng())
698 .InputWidth(input_rng())
699 .InputChannels(channel_rng())
700 .OutputChannels(channel_rng())
701 .KernelHeight(kernel_rng())
702 .KernelWidth(kernel_rng())
703 .StrideHeight(stride_rng())
704 .StrideWidth(stride_rng())
705 .SignBitActivation()
706 .Test(xnnpack_delegate.get());
707 }
708
TEST(Conv2D,MultiThreading)709 TEST(Conv2D, MultiThreading) {
710 TfLiteXNNPackDelegateOptions delegate_options =
711 TfLiteXNNPackDelegateOptionsDefault();
712 delegate_options.num_threads = 2;
713 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
714 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
715 TfLiteXNNPackDelegateDelete);
716
717 std::random_device random_device;
718 auto rng = std::mt19937(random_device());
719 auto batch_rng =
720 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
721 auto input_rng =
722 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
723 auto kernel_rng =
724 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
725 auto stride_rng =
726 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
727 auto channel_rng =
728 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
729
730 Conv2DTester()
731 .BatchSize(batch_rng())
732 .InputHeight(input_rng())
733 .InputWidth(input_rng())
734 .InputChannels(channel_rng())
735 .OutputChannels(channel_rng())
736 .KernelHeight(kernel_rng())
737 .KernelWidth(kernel_rng())
738 .StrideHeight(stride_rng())
739 .StrideWidth(stride_rng())
740 .Test(xnnpack_delegate.get());
741 }
742
TEST(Conv2D,WeightsCache)743 TEST(Conv2D, WeightsCache) {
744 TfLiteXNNPackDelegateOptions delegate_options =
745 TfLiteXNNPackDelegateOptionsDefault();
746 std::unique_ptr<TfLiteXNNPackDelegateWeightsCache,
747 decltype(&TfLiteXNNPackDelegateWeightsCacheDelete)>
748 weights_cache(TfLiteXNNPackDelegateWeightsCacheCreate(),
749 TfLiteXNNPackDelegateWeightsCacheDelete);
750 delegate_options.weights_cache = weights_cache.get();
751
752 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
753 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
754 TfLiteXNNPackDelegateDelete);
755
756 std::random_device random_device;
757 auto rng = std::mt19937(random_device());
758 auto batch_rng =
759 std::bind(std::uniform_int_distribution<int32_t>(2, 4), std::ref(rng));
760 auto input_rng =
761 std::bind(std::uniform_int_distribution<int32_t>(10, 25), std::ref(rng));
762 auto kernel_rng =
763 std::bind(std::uniform_int_distribution<int32_t>(3, 5), std::ref(rng));
764 auto stride_rng =
765 std::bind(std::uniform_int_distribution<int32_t>(2, 3), std::ref(rng));
766 auto channel_rng =
767 std::bind(std::uniform_int_distribution<int32_t>(1, 16), std::ref(rng));
768
769 Conv2DTester()
770 .BatchSize(batch_rng())
771 .InputHeight(input_rng())
772 .InputWidth(input_rng())
773 .InputChannels(channel_rng())
774 .OutputChannels(channel_rng())
775 .KernelHeight(kernel_rng())
776 .KernelWidth(kernel_rng())
777 .StrideHeight(stride_rng())
778 .StrideWidth(stride_rng())
779 .WeightsCache(weights_cache.get())
780 .Test(xnnpack_delegate.get());
781 }
782
783 } // namespace xnnpack
784 } // namespace tflite
785