Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / XNNPACK / f568f08ef1d1245c159969441d25bcd172183dbf / . / test / deconvolution.cc
blob: 30ef3ea22800e59993cee12bc57e0aaf04505a1f [file] [log] [blame]
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1// Copyright 2019 Google LLC
2//
3// This source code is licensed under the BSD-style license found in the
4// LICENSE file in the root directory of this source tree.
5
6#include <gtest/gtest.h>
7
8#include <xnnpack/params.h>
9
10#include "deconvolution-operator-tester.h"
11
12
13/**************************** Future GEMM path ****************************/
14
15TEST(DECONVOLUTION_OP_Q8, 1x1) {
16 ASSERT_EQ(xnn_status_success, xnn_initialize());
17 DeconvolutionOperatorTester()
18 .input_size(27, 29)
19 .kernel_size(1, 1)
20 .group_input_channels(23)
21 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
22 .iterations(3)
23 .TestQ8();
24}
25
26TEST(DECONVOLUTION_OP_Q8, 1x1_varying_input_width) {
27 ASSERT_EQ(xnn_status_success, xnn_initialize());
28 for (size_t input_width = 25; input_width <= 31; input_width++) {
29 DeconvolutionOperatorTester()
30 .input_size(input_width, 29)
31 .kernel_size(1, 1)
32 .group_input_channels(23)
33 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
34 .iterations(1)
35 .TestQ8();
36 }
37}
38
39TEST(DECONVOLUTION_OP_Q8, 1x1_varying_input_height) {
40 ASSERT_EQ(xnn_status_success, xnn_initialize());
41 for (size_t input_height = 27; input_height <= 33; input_height++) {
42 DeconvolutionOperatorTester()
43 .input_size(27, input_height)
44 .kernel_size(1, 1)
45 .group_input_channels(23)
46 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
47 .iterations(1)
48 .TestQ8();
49 }
50}
51
52TEST(DECONVOLUTION_OP_Q8, 1x1_varying_input_channels) {
53 ASSERT_EQ(xnn_status_success, xnn_initialize());
54 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
55 DeconvolutionOperatorTester()
56 .input_size(27, 29)
57 .kernel_size(1, 1)
58 .group_input_channels(input_channels)
59 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
60 .iterations(1)
61 .TestQ8();
62 }
63}
64
65TEST(DECONVOLUTION_OP_Q8, 1x1_varying_output_channels) {
66 ASSERT_EQ(xnn_status_success, xnn_initialize());
67 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
68 DeconvolutionOperatorTester()
69 .input_size(27, 29)
70 .kernel_size(1, 1)
71 .group_input_channels(23)
72 .group_output_channels(output_channels)
73 .iterations(1)
74 .TestQ8();
75 }
76}
77
78TEST(DECONVOLUTION_OP_Q8, 1x1_with_input_stride) {
79 ASSERT_EQ(xnn_status_success, xnn_initialize());
80 DeconvolutionOperatorTester()
81 .input_size(27, 29)
82 .kernel_size(1, 1)
83 .group_input_channels(23)
84 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
85 .input_pixel_stride(28)
86 .iterations(3)
87 .TestQ8();
88}
89
90TEST(DECONVOLUTION_OP_Q8, 1x1_with_output_stride) {
91 ASSERT_EQ(xnn_status_success, xnn_initialize());
92 DeconvolutionOperatorTester()
93 .input_size(27, 29)
94 .kernel_size(1, 1)
95 .group_input_channels(23)
96 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
97 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
98 .iterations(3)
99 .TestQ8();
100}
101
102TEST(DECONVOLUTION_OP_Q8, 1x1_with_qmin) {
103 ASSERT_EQ(xnn_status_success, xnn_initialize());
104 DeconvolutionOperatorTester()
105 .input_size(27, 29)
106 .kernel_size(1, 1)
107 .group_input_channels(23)
108 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
109 .qmin(128)
110 .iterations(3)
111 .TestQ8();
112}
113
114TEST(DECONVOLUTION_OP_Q8, 1x1_with_qmax) {
115 ASSERT_EQ(xnn_status_success, xnn_initialize());
116 DeconvolutionOperatorTester()
117 .input_size(27, 29)
118 .kernel_size(1, 1)
119 .group_input_channels(23)
120 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
121 .qmin(128)
122 .iterations(3)
123 .TestQ8();
124}
125
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]126TEST(DECONVOLUTION_OP_Q8, 1x1_without_bias) {
127 ASSERT_EQ(xnn_status_success, xnn_initialize());
128 DeconvolutionOperatorTester()
129 .has_bias(false)
130 .input_size(27, 29)
131 .kernel_size(1, 1)
132 .group_input_channels(23)
133 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
134 .iterations(3)
135 .TestQ8();
136}
137
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]138/**************************** Future GEMM path, grouped ****************************/
139
140TEST(DECONVOLUTION_OP_Q8, grouped_1x1) {
141 ASSERT_EQ(xnn_status_success, xnn_initialize());
142 DeconvolutionOperatorTester()
143 .input_size(27, 29)
144 .kernel_size(1, 1)
145 .groups(2)
146 .group_input_channels(23)
147 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
148 .iterations(3)
149 .TestQ8();
150}
151
152TEST(DECONVOLUTION_OP_Q8, grouped_1x1_varying_input_width) {
153 ASSERT_EQ(xnn_status_success, xnn_initialize());
154 for (size_t input_width = 25; input_width <= 31; input_width++) {
155 DeconvolutionOperatorTester()
156 .input_size(input_width, 29)
157 .kernel_size(1, 1)
158 .groups(2)
159 .group_input_channels(23)
160 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
161 .iterations(1)
162 .TestQ8();
163 }
164}
165
166TEST(DECONVOLUTION_OP_Q8, grouped_1x1_varying_input_height) {
167 ASSERT_EQ(xnn_status_success, xnn_initialize());
168 for (size_t input_height = 27; input_height <= 33; input_height++) {
169 DeconvolutionOperatorTester()
170 .input_size(27, input_height)
171 .kernel_size(1, 1)
172 .groups(2)
173 .group_input_channels(23)
174 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
175 .iterations(1)
176 .TestQ8();
177 }
178}
179
180TEST(DECONVOLUTION_OP_Q8, grouped_1x1_varying_input_channels) {
181 ASSERT_EQ(xnn_status_success, xnn_initialize());
182 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
183 DeconvolutionOperatorTester()
184 .input_size(27, 29)
185 .kernel_size(1, 1)
186 .groups(2)
187 .group_input_channels(input_channels)
188 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
189 .iterations(1)
190 .TestQ8();
191 }
192}
193
194TEST(DECONVOLUTION_OP_Q8, grouped_1x1_varying_output_channels) {
195 ASSERT_EQ(xnn_status_success, xnn_initialize());
196 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
197 DeconvolutionOperatorTester()
198 .input_size(27, 29)
199 .kernel_size(1, 1)
200 .groups(2)
201 .group_input_channels(23)
202 .group_output_channels(output_channels)
203 .iterations(1)
204 .TestQ8();
205 }
206}
207
208TEST(DECONVOLUTION_OP_Q8, grouped_1x1_with_input_stride) {
209 ASSERT_EQ(xnn_status_success, xnn_initialize());
210 DeconvolutionOperatorTester()
211 .input_size(27, 29)
212 .kernel_size(1, 1)
213 .groups(2)
214 .group_input_channels(23)
215 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
216 .input_pixel_stride(47)
217 .iterations(3)
218 .TestQ8();
219}
220
221TEST(DECONVOLUTION_OP_Q8, grouped_1x1_with_output_stride) {
222 ASSERT_EQ(xnn_status_success, xnn_initialize());
223 DeconvolutionOperatorTester()
224 .input_size(27, 29)
225 .kernel_size(1, 1)
226 .groups(2)
227 .group_input_channels(23)
228 .group_output_channels(xnn_params.q8.gemm.nr + 3)
229 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
230 .iterations(3)
231 .TestQ8();
232}
233
234TEST(DECONVOLUTION_OP_Q8, grouped_1x1_with_qmin) {
235 ASSERT_EQ(xnn_status_success, xnn_initialize());
236 DeconvolutionOperatorTester()
237 .input_size(27, 29)
238 .kernel_size(1, 1)
239 .groups(2)
240 .group_input_channels(23)
241 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
242 .qmin(128)
243 .iterations(3)
244 .TestQ8();
245}
246
247TEST(DECONVOLUTION_OP_Q8, grouped_1x1_with_qmax) {
248 ASSERT_EQ(xnn_status_success, xnn_initialize());
249 DeconvolutionOperatorTester()
250 .input_size(27, 29)
251 .kernel_size(1, 1)
252 .groups(2)
253 .group_input_channels(23)
254 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
255 .qmin(128)
256 .iterations(3)
257 .TestQ8();
258}
259
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]260TEST(DECONVOLUTION_OP_Q8, grouped_1x1_without_bias) {
261 ASSERT_EQ(xnn_status_success, xnn_initialize());
262 DeconvolutionOperatorTester()
263 .has_bias(false)
264 .input_size(27, 29)
265 .kernel_size(1, 1)
266 .groups(2)
267 .group_input_channels(23)
268 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
269 .iterations(3)
270 .TestQ8();
271}
272
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]273/**************************** Future GEMM path, batched ****************************/
274
275TEST(DECONVOLUTION_OP_Q8, batched_1x1) {
276 ASSERT_EQ(xnn_status_success, xnn_initialize());
277 DeconvolutionOperatorTester()
278 .batch_size(2)
279 .input_size(27, 29)
280 .kernel_size(1, 1)
281 .group_input_channels(23)
282 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
283 .iterations(3)
284 .TestQ8();
285}
286
287TEST(DECONVOLUTION_OP_Q8, batched_1x1_varying_input_width) {
288 ASSERT_EQ(xnn_status_success, xnn_initialize());
289 for (size_t input_width = 25; input_width <= 31; input_width++) {
290 DeconvolutionOperatorTester()
291 .batch_size(2)
292 .input_size(input_width, 29)
293 .kernel_size(1, 1)
294 .group_input_channels(23)
295 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
296 .iterations(1)
297 .TestQ8();
298 }
299}
300
301TEST(DECONVOLUTION_OP_Q8, batched_1x1_varying_input_height) {
302 ASSERT_EQ(xnn_status_success, xnn_initialize());
303 for (size_t input_height = 27; input_height <= 33; input_height++) {
304 DeconvolutionOperatorTester()
305 .batch_size(2)
306 .input_size(27, input_height)
307 .kernel_size(1, 1)
308 .group_input_channels(23)
309 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
310 .iterations(1)
311 .TestQ8();
312 }
313}
314
315TEST(DECONVOLUTION_OP_Q8, batched_1x1_varying_input_channels) {
316 ASSERT_EQ(xnn_status_success, xnn_initialize());
317 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
318 DeconvolutionOperatorTester()
319 .batch_size(2)
320 .input_size(27, 29)
321 .kernel_size(1, 1)
322 .group_input_channels(input_channels)
323 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
324 .iterations(1)
325 .TestQ8();
326 }
327}
328
329TEST(DECONVOLUTION_OP_Q8, batched_1x1_varying_output_channels) {
330 ASSERT_EQ(xnn_status_success, xnn_initialize());
331 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
332 DeconvolutionOperatorTester()
333 .batch_size(2)
334 .input_size(27, 29)
335 .kernel_size(1, 1)
336 .group_input_channels(23)
337 .group_output_channels(output_channels)
338 .iterations(1)
339 .TestQ8();
340 }
341}
342
343TEST(DECONVOLUTION_OP_Q8, batched_1x1_with_input_stride) {
344 ASSERT_EQ(xnn_status_success, xnn_initialize());
345 DeconvolutionOperatorTester()
346 .batch_size(2)
347 .input_size(27, 29)
348 .kernel_size(1, 1)
349 .group_input_channels(23)
350 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
351 .input_pixel_stride(28)
352 .iterations(3)
353 .TestQ8();
354}
355
356TEST(DECONVOLUTION_OP_Q8, batched_1x1_with_output_stride) {
357 ASSERT_EQ(xnn_status_success, xnn_initialize());
358 DeconvolutionOperatorTester()
359 .batch_size(2)
360 .input_size(27, 29)
361 .kernel_size(1, 1)
362 .group_input_channels(23)
363 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
364 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
365 .iterations(3)
366 .TestQ8();
367}
368
369TEST(DECONVOLUTION_OP_Q8, batched_1x1_with_qmin) {
370 ASSERT_EQ(xnn_status_success, xnn_initialize());
371 DeconvolutionOperatorTester()
372 .batch_size(2)
373 .input_size(27, 29)
374 .kernel_size(1, 1)
375 .group_input_channels(23)
376 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
377 .qmin(128)
378 .iterations(3)
379 .TestQ8();
380}
381
382TEST(DECONVOLUTION_OP_Q8, batched_1x1_with_qmax) {
383 ASSERT_EQ(xnn_status_success, xnn_initialize());
384 DeconvolutionOperatorTester()
385 .batch_size(2)
386 .input_size(27, 29)
387 .kernel_size(1, 1)
388 .group_input_channels(23)
389 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
390 .qmin(128)
391 .iterations(3)
392 .TestQ8();
393}
394
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]395TEST(DECONVOLUTION_OP_Q8, batched_1x1_without_bias) {
396 ASSERT_EQ(xnn_status_success, xnn_initialize());
397 DeconvolutionOperatorTester()
398 .has_bias(false)
399 .batch_size(2)
400 .input_size(27, 29)
401 .kernel_size(1, 1)
402 .group_input_channels(23)
403 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
404 .iterations(3)
405 .TestQ8();
406}
407
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]408/**************************** Future GEMM path, batched, grouped ****************************/
409
410TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1) {
411 ASSERT_EQ(xnn_status_success, xnn_initialize());
412 DeconvolutionOperatorTester()
413 .batch_size(2)
414 .input_size(27, 29)
415 .kernel_size(1, 1)
416 .groups(2)
417 .group_input_channels(23)
418 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
419 .iterations(3)
420 .TestQ8();
421}
422
423TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_varying_input_width) {
424 ASSERT_EQ(xnn_status_success, xnn_initialize());
425 for (size_t input_width = 25; input_width <= 31; input_width++) {
426 DeconvolutionOperatorTester()
427 .batch_size(2)
428 .input_size(input_width, 29)
429 .kernel_size(1, 1)
430 .groups(2)
431 .group_input_channels(23)
432 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
433 .iterations(1)
434 .TestQ8();
435 }
436}
437
438TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_varying_input_height) {
439 ASSERT_EQ(xnn_status_success, xnn_initialize());
440 for (size_t input_height = 27; input_height <= 33; input_height++) {
441 DeconvolutionOperatorTester()
442 .batch_size(2)
443 .input_size(27, input_height)
444 .kernel_size(1, 1)
445 .groups(2)
446 .group_input_channels(23)
447 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
448 .iterations(1)
449 .TestQ8();
450 }
451}
452
453TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_varying_input_channels) {
454 ASSERT_EQ(xnn_status_success, xnn_initialize());
455 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
456 DeconvolutionOperatorTester()
457 .batch_size(2)
458 .input_size(27, 29)
459 .kernel_size(1, 1)
460 .groups(2)
461 .group_input_channels(input_channels)
462 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
463 .iterations(1)
464 .TestQ8();
465 }
466}
467
468TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_varying_output_channels) {
469 ASSERT_EQ(xnn_status_success, xnn_initialize());
470 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
471 DeconvolutionOperatorTester()
472 .batch_size(2)
473 .input_size(27, 29)
474 .kernel_size(1, 1)
475 .groups(2)
476 .group_input_channels(23)
477 .group_output_channels(output_channels)
478 .iterations(1)
479 .TestQ8();
480 }
481}
482
483TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_with_input_stride) {
484 ASSERT_EQ(xnn_status_success, xnn_initialize());
485 DeconvolutionOperatorTester()
486 .batch_size(2)
487 .input_size(27, 29)
488 .kernel_size(1, 1)
489 .groups(2)
490 .group_input_channels(23)
491 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
492 .input_pixel_stride(47)
493 .iterations(3)
494 .TestQ8();
495}
496
497TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_with_output_stride) {
498 ASSERT_EQ(xnn_status_success, xnn_initialize());
499 DeconvolutionOperatorTester()
500 .batch_size(2)
501 .input_size(27, 29)
502 .kernel_size(1, 1)
503 .groups(2)
504 .group_input_channels(23)
505 .group_output_channels(xnn_params.q8.gemm.nr + 3)
506 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
507 .iterations(3)
508 .TestQ8();
509}
510
511TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_with_qmin) {
512 ASSERT_EQ(xnn_status_success, xnn_initialize());
513 DeconvolutionOperatorTester()
514 .batch_size(2)
515 .input_size(27, 29)
516 .kernel_size(1, 1)
517 .groups(2)
518 .group_input_channels(23)
519 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
520 .qmin(128)
521 .iterations(3)
522 .TestQ8();
523}
524
525TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_with_qmax) {
526 ASSERT_EQ(xnn_status_success, xnn_initialize());
527 DeconvolutionOperatorTester()
528 .batch_size(2)
529 .input_size(27, 29)
530 .kernel_size(1, 1)
531 .groups(2)
532 .group_input_channels(23)
533 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
534 .qmin(128)
535 .iterations(3)
536 .TestQ8();
537}
538
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]539TEST(DECONVOLUTION_OP_Q8, batched_grouped_1x1_without_bias) {
540 ASSERT_EQ(xnn_status_success, xnn_initialize());
541 DeconvolutionOperatorTester()
542 .has_bias(false)
543 .batch_size(2)
544 .input_size(27, 29)
545 .kernel_size(1, 1)
546 .groups(2)
547 .group_input_channels(23)
548 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
549 .iterations(3)
550 .TestQ8();
551}
552
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]553/**************************** CONV path ****************************/
554
555TEST(DECONVOLUTION_OP_Q8, 3x3) {
556 ASSERT_EQ(xnn_status_success, xnn_initialize());
557 DeconvolutionOperatorTester()
558 .input_size(13, 12)
559 .padding(1)
560 .kernel_size(3, 3)
561 .group_input_channels(15)
562 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
563 .iterations(3)
564 .TestQ8();
565}
566
567TEST(DECONVOLUTION_OP_Q8, Kx3) {
568 ASSERT_EQ(xnn_status_success, xnn_initialize());
569 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
570 DeconvolutionOperatorTester()
571 .input_size(13, 12)
572 .padding_width(1)
573 .kernel_size(kernel_height, 3)
574 .group_input_channels(17)
575 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
576 .iterations(3)
577 .TestQ8();
578 }
579}
580
581TEST(DECONVOLUTION_OP_Q8, 3xK) {
582 ASSERT_EQ(xnn_status_success, xnn_initialize());
583 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
584 DeconvolutionOperatorTester()
585 .input_size(13, 12)
586 .padding_height(1)
587 .kernel_size(3, kernel_width)
588 .group_input_channels(17)
589 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
590 .iterations(3)
591 .TestQ8();
592 }
593}
594
595TEST(DECONVOLUTION_OP_Q8, 3x3_varying_height_padding) {
596 ASSERT_EQ(xnn_status_success, xnn_initialize());
597 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
598 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
599 DeconvolutionOperatorTester()
600 .input_size(13, 12)
601 .padding_width(1)
602 .padding_top(padding_top)
603 .padding_bottom(padding_bottom)
604 .kernel_size(3, 3)
605 .group_input_channels(15)
606 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
607 .iterations(1)
608 .TestQ8();
609 }
610 }
611}
612
613TEST(DECONVOLUTION_OP_Q8, 3x3_varying_width_padding) {
614 ASSERT_EQ(xnn_status_success, xnn_initialize());
615 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
616 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
617 DeconvolutionOperatorTester()
618 .input_size(13, 12)
619 .padding_height(1)
620 .padding_left(padding_left)
621 .padding_right(padding_right)
622 .kernel_size(3, 3)
623 .group_input_channels(15)
624 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
625 .iterations(1)
626 .TestQ8();
627 }
628 }
629}
630
631TEST(DECONVOLUTION_OP_Q8, 3x3_varying_height_adjustment) {
632 ASSERT_EQ(xnn_status_success, xnn_initialize());
633 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
634 DeconvolutionOperatorTester()
635 .input_size(13, 12)
636 .padding(1)
637 .adjustment_height(adjustment_height)
638 .kernel_size(3, 3)
639 .group_input_channels(15)
640 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
641 .iterations(1)
642 .TestQ8();
643 }
644}
645
646TEST(DECONVOLUTION_OP_Q8, 3x3_varying_width_adjustment) {
647 ASSERT_EQ(xnn_status_success, xnn_initialize());
648 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
649 DeconvolutionOperatorTester()
650 .input_size(13, 12)
651 .padding(1)
652 .adjustment_width(adjustment_width)
653 .kernel_size(3, 3)
654 .group_input_channels(15)
655 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
656 .iterations(1)
657 .TestQ8();
658 }
659}
660
661TEST(DECONVOLUTION_OP_Q8, 3x3_varying_input_height) {
662 ASSERT_EQ(xnn_status_success, xnn_initialize());
663 for (size_t input_height = 10; input_height <= 15; input_height++) {
664 DeconvolutionOperatorTester()
665 .input_size(input_height, 12)
666 .padding(1)
667 .kernel_size(3, 3)
668 .group_input_channels(15)
669 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
670 .iterations(1)
671 .TestQ8();
672 }
673}
674
675TEST(DECONVOLUTION_OP_Q8, 3x3_varying_input_width) {
676 ASSERT_EQ(xnn_status_success, xnn_initialize());
677 for (size_t input_width = 9; input_width <= 14; input_width++) {
678 DeconvolutionOperatorTester()
679 .input_size(13, input_width)
680 .padding(1)
681 .kernel_size(3, 3)
682 .group_input_channels(15)
683 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
684 .iterations(1)
685 .TestQ8();
686 }
687}
688
689TEST(DECONVOLUTION_OP_Q8, 3x3_varying_input_channels) {
690 ASSERT_EQ(xnn_status_success, xnn_initialize());
691 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
692 DeconvolutionOperatorTester()
693 .input_size(13, 12)
694 .padding(1)
695 .kernel_size(3, 3)
696 .group_input_channels(input_channels)
697 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
698 .iterations(1)
699 .TestQ8();
700 }
701}
702
703TEST(DECONVOLUTION_OP_Q8, 3x3_varying_output_channels) {
704 ASSERT_EQ(xnn_status_success, xnn_initialize());
705 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
706 DeconvolutionOperatorTester()
707 .input_size(13, 12)
708 .padding(1)
709 .kernel_size(3, 3)
710 .group_input_channels(23)
711 .group_output_channels(output_channels)
712 .iterations(1)
713 .TestQ8();
714 }
715}
716
717TEST(DECONVOLUTION_OP_Q8, 3x3_with_height_dilation) {
718 ASSERT_EQ(xnn_status_success, xnn_initialize());
719 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
720 DeconvolutionOperatorTester()
721 .input_size(13, 12)
722 .padding(1)
723 .kernel_size(3, 3)
724 .dilation_height(dilation_height)
725 .group_input_channels(23)
726 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
727 .iterations(3)
728 .TestQ8();
729 }
730}
731
732TEST(DECONVOLUTION_OP_Q8, 3x3_with_width_dilation) {
733 ASSERT_EQ(xnn_status_success, xnn_initialize());
734 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
735 DeconvolutionOperatorTester()
736 .input_size(13, 12)
737 .padding(1)
738 .kernel_size(3, 3)
739 .dilation_width(dilation_width)
740 .group_input_channels(23)
741 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
742 .iterations(3)
743 .TestQ8();
744 }
745}
746
747TEST(DECONVOLUTION_OP_Q8, 3x3_with_height_dilation_and_stride) {
748 ASSERT_EQ(xnn_status_success, xnn_initialize());
749 DeconvolutionOperatorTester()
750 .input_size(10, 9)
751 .padding(1)
752 .kernel_size(3, 3)
753 .dilation_height(3)
754 .stride_height(2)
755 .group_input_channels(23)
756 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
757 .iterations(3)
758 .TestQ8();
759}
760
761TEST(DECONVOLUTION_OP_Q8, 3x3_with_width_dilation_and_stride) {
762 ASSERT_EQ(xnn_status_success, xnn_initialize());
763 DeconvolutionOperatorTester()
764 .input_size(10, 9)
765 .padding(1)
766 .kernel_size(3, 3)
767 .dilation_width(3)
768 .stride_width(2)
769 .group_input_channels(23)
770 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
771 .iterations(3)
772 .TestQ8();
773}
774
775TEST(DECONVOLUTION_OP_Q8, 3x3_with_input_stride) {
776 ASSERT_EQ(xnn_status_success, xnn_initialize());
777 DeconvolutionOperatorTester()
778 .input_size(13, 12)
779 .padding(1)
780 .kernel_size(3, 3)
781 .group_input_channels(23)
782 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
783 .input_pixel_stride(28)
784 .iterations(3)
785 .TestQ8();
786}
787
788TEST(DECONVOLUTION_OP_Q8, 3x3_with_output_stride) {
789 ASSERT_EQ(xnn_status_success, xnn_initialize());
790 DeconvolutionOperatorTester()
791 .input_size(13, 12)
792 .padding(1)
793 .kernel_size(3, 3)
794 .group_input_channels(23)
795 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
796 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
797 .iterations(3)
798 .TestQ8();
799}
800
801TEST(DECONVOLUTION_OP_Q8, 3x3_with_qmin) {
802 ASSERT_EQ(xnn_status_success, xnn_initialize());
803 DeconvolutionOperatorTester()
804 .input_size(13, 12)
805 .padding(1)
806 .kernel_size(3, 3)
807 .group_input_channels(23)
808 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
809 .qmin(128)
810 .iterations(3)
811 .TestQ8();
812}
813
814TEST(DECONVOLUTION_OP_Q8, 3x3_with_qmax) {
815 ASSERT_EQ(xnn_status_success, xnn_initialize());
816 DeconvolutionOperatorTester()
817 .input_size(13, 12)
818 .padding(1)
819 .kernel_size(3, 3)
820 .group_input_channels(23)
821 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
822 .qmin(128)
823 .iterations(3)
824 .TestQ8();
825}
826
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]827TEST(DECONVOLUTION_OP_Q8, 3x3_without_bias) {
828 ASSERT_EQ(xnn_status_success, xnn_initialize());
829 DeconvolutionOperatorTester()
830 .has_bias(false)
831 .input_size(13, 12)
832 .padding(1)
833 .kernel_size(3, 3)
834 .group_input_channels(23)
835 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
836 .iterations(3)
837 .TestQ8();
838}
839
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]840/**************************** CONV path, grouped ****************************/
841
842TEST(DECONVOLUTION_OP_Q8, grouped_3x3) {
843 ASSERT_EQ(xnn_status_success, xnn_initialize());
844 DeconvolutionOperatorTester()
845 .input_size(13, 12)
846 .padding(1)
847 .kernel_size(3, 3)
848 .groups(2)
849 .group_input_channels(15)
850 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
851 .iterations(3)
852 .TestQ8();
853}
854
855TEST(DECONVOLUTION_OP_Q8, grouped_Kx3) {
856 ASSERT_EQ(xnn_status_success, xnn_initialize());
857 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
858 DeconvolutionOperatorTester()
859 .input_size(13, 12)
860 .padding_width(1)
861 .kernel_size(kernel_height, 3)
862 .groups(2)
863 .group_input_channels(17)
864 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
865 .iterations(3)
866 .TestQ8();
867 }
868}
869
870TEST(DECONVOLUTION_OP_Q8, grouped_3xK) {
871 ASSERT_EQ(xnn_status_success, xnn_initialize());
872 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
873 DeconvolutionOperatorTester()
874 .input_size(13, 12)
875 .padding_height(1)
876 .kernel_size(3, kernel_width)
877 .groups(2)
878 .group_input_channels(17)
879 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
880 .iterations(3)
881 .TestQ8();
882 }
883}
884
885TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_height_padding) {
886 ASSERT_EQ(xnn_status_success, xnn_initialize());
887 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
888 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
889 DeconvolutionOperatorTester()
890 .input_size(13, 12)
891 .padding_width(1)
892 .padding_top(padding_top)
893 .padding_bottom(padding_bottom)
894 .kernel_size(3, 3)
895 .groups(2)
896 .group_input_channels(15)
897 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
898 .iterations(1)
899 .TestQ8();
900 }
901 }
902}
903
904TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_width_padding) {
905 ASSERT_EQ(xnn_status_success, xnn_initialize());
906 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
907 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
908 DeconvolutionOperatorTester()
909 .input_size(13, 12)
910 .padding_height(1)
911 .padding_left(padding_left)
912 .padding_right(padding_right)
913 .kernel_size(3, 3)
914 .groups(2)
915 .group_input_channels(15)
916 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
917 .iterations(1)
918 .TestQ8();
919 }
920 }
921}
922
923TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_height_adjustment) {
924 ASSERT_EQ(xnn_status_success, xnn_initialize());
925 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
926 DeconvolutionOperatorTester()
927 .input_size(13, 12)
928 .padding(1)
929 .adjustment_height(adjustment_height)
930 .kernel_size(3, 3)
931 .groups(2)
932 .group_input_channels(15)
933 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
934 .iterations(1)
935 .TestQ8();
936 }
937}
938
939TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_width_adjustment) {
940 ASSERT_EQ(xnn_status_success, xnn_initialize());
941 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
942 DeconvolutionOperatorTester()
943 .input_size(13, 12)
944 .padding(1)
945 .adjustment_width(adjustment_width)
946 .kernel_size(3, 3)
947 .groups(2)
948 .group_input_channels(15)
949 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
950 .iterations(1)
951 .TestQ8();
952 }
953}
954
955TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_input_height) {
956 ASSERT_EQ(xnn_status_success, xnn_initialize());
957 for (size_t input_height = 10; input_height <= 15; input_height++) {
958 DeconvolutionOperatorTester()
959 .input_size(input_height, 12)
960 .padding(1)
961 .kernel_size(3, 3)
962 .groups(2)
963 .group_input_channels(15)
964 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
965 .iterations(1)
966 .TestQ8();
967 }
968}
969
970TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_input_width) {
971 ASSERT_EQ(xnn_status_success, xnn_initialize());
972 for (size_t input_width = 9; input_width <= 14; input_width++) {
973 DeconvolutionOperatorTester()
974 .input_size(13, input_width)
975 .padding(1)
976 .kernel_size(3, 3)
977 .groups(2)
978 .group_input_channels(15)
979 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
980 .iterations(1)
981 .TestQ8();
982 }
983}
984
985TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_input_channels) {
986 ASSERT_EQ(xnn_status_success, xnn_initialize());
987 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
988 DeconvolutionOperatorTester()
989 .input_size(13, 12)
990 .padding(1)
991 .kernel_size(3, 3)
992 .groups(2)
993 .group_input_channels(input_channels)
994 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
995 .iterations(1)
996 .TestQ8();
997 }
998}
999
1000TEST(DECONVOLUTION_OP_Q8, grouped_3x3_varying_output_channels) {
1001 ASSERT_EQ(xnn_status_success, xnn_initialize());
1002 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
1003 DeconvolutionOperatorTester()
1004 .input_size(13, 12)
1005 .padding(1)
1006 .kernel_size(3, 3)
1007 .groups(2)
1008 .group_input_channels(23)
1009 .group_output_channels(output_channels)
1010 .iterations(1)
1011 .TestQ8();
1012 }
1013}
1014
1015TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_height_dilation) {
1016 ASSERT_EQ(xnn_status_success, xnn_initialize());
1017 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
1018 DeconvolutionOperatorTester()
1019 .input_size(13, 12)
1020 .padding(1)
1021 .kernel_size(3, 3)
1022 .dilation_height(dilation_height)
1023 .groups(2)
1024 .group_input_channels(23)
1025 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1026 .iterations(3)
1027 .TestQ8();
1028 }
1029}
1030
1031TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_width_dilation) {
1032 ASSERT_EQ(xnn_status_success, xnn_initialize());
1033 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
1034 DeconvolutionOperatorTester()
1035 .input_size(13, 12)
1036 .padding(1)
1037 .kernel_size(3, 3)
1038 .dilation_width(dilation_width)
1039 .groups(2)
1040 .group_input_channels(23)
1041 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1042 .iterations(3)
1043 .TestQ8();
1044 }
1045}
1046
1047TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_height_dilation_and_stride) {
1048 ASSERT_EQ(xnn_status_success, xnn_initialize());
1049 DeconvolutionOperatorTester()
1050 .input_size(10, 9)
1051 .padding(1)
1052 .kernel_size(3, 3)
1053 .dilation_height(3)
1054 .stride_height(2)
1055 .groups(2)
1056 .group_input_channels(23)
1057 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1058 .iterations(3)
1059 .TestQ8();
1060}
1061
1062TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_width_dilation_and_stride) {
1063 ASSERT_EQ(xnn_status_success, xnn_initialize());
1064 DeconvolutionOperatorTester()
1065 .input_size(10, 9)
1066 .padding(1)
1067 .kernel_size(3, 3)
1068 .dilation_width(3)
1069 .stride_width(2)
1070 .groups(2)
1071 .group_input_channels(23)
1072 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1073 .iterations(3)
1074 .TestQ8();
1075}
1076
1077TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_input_stride) {
1078 ASSERT_EQ(xnn_status_success, xnn_initialize());
1079 DeconvolutionOperatorTester()
1080 .input_size(13, 12)
1081 .padding(1)
1082 .kernel_size(3, 3)
1083 .groups(2)
1084 .group_input_channels(23)
1085 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1086 .input_pixel_stride(47)
1087 .iterations(3)
1088 .TestQ8();
1089}
1090
1091TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_output_stride) {
1092 ASSERT_EQ(xnn_status_success, xnn_initialize());
1093 DeconvolutionOperatorTester()
1094 .input_size(13, 12)
1095 .padding(1)
1096 .kernel_size(3, 3)
1097 .groups(2)
1098 .group_input_channels(23)
1099 .group_output_channels(xnn_params.q8.gemm.nr + 3)
1100 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
1101 .iterations(3)
1102 .TestQ8();
1103}
1104
1105TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_qmin) {
1106 ASSERT_EQ(xnn_status_success, xnn_initialize());
1107 DeconvolutionOperatorTester()
1108 .input_size(13, 12)
1109 .padding(1)
1110 .kernel_size(3, 3)
1111 .groups(2)
1112 .group_input_channels(23)
1113 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1114 .qmin(128)
1115 .iterations(3)
1116 .TestQ8();
1117}
1118
1119TEST(DECONVOLUTION_OP_Q8, grouped_3x3_with_qmax) {
1120 ASSERT_EQ(xnn_status_success, xnn_initialize());
1121 DeconvolutionOperatorTester()
1122 .input_size(13, 12)
1123 .padding(1)
1124 .kernel_size(3, 3)
1125 .groups(2)
1126 .group_input_channels(23)
1127 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1128 .qmin(128)
1129 .iterations(3)
1130 .TestQ8();
1131}
1132
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]1133TEST(DECONVOLUTION_OP_Q8, grouped_3x3_without_bias) {
1134 ASSERT_EQ(xnn_status_success, xnn_initialize());
1135 DeconvolutionOperatorTester()
1136 .has_bias(false)
1137 .input_size(13, 12)
1138 .padding(1)
1139 .kernel_size(3, 3)
1140 .groups(2)
1141 .group_input_channels(23)
1142 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1143 .iterations(3)
1144 .TestQ8();
1145}
1146
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1147/**************************** CONV path, batched ****************************/
1148
1149TEST(DECONVOLUTION_OP_Q8, batched_3x3) {
1150 ASSERT_EQ(xnn_status_success, xnn_initialize());
1151 DeconvolutionOperatorTester()
1152 .batch_size(2)
1153 .input_size(13, 12)
1154 .padding(1)
1155 .kernel_size(3, 3)
1156 .group_input_channels(15)
1157 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1158 .iterations(3)
1159 .TestQ8();
1160}
1161
1162TEST(DECONVOLUTION_OP_Q8, batched_Kx3) {
1163 ASSERT_EQ(xnn_status_success, xnn_initialize());
1164 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
1165 DeconvolutionOperatorTester()
1166 .batch_size(2)
1167 .input_size(13, 12)
1168 .padding_width(1)
1169 .kernel_size(kernel_height, 3)
1170 .group_input_channels(17)
1171 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1172 .iterations(3)
1173 .TestQ8();
1174 }
1175}
1176
1177TEST(DECONVOLUTION_OP_Q8, batched_3xK) {
1178 ASSERT_EQ(xnn_status_success, xnn_initialize());
1179 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
1180 DeconvolutionOperatorTester()
1181 .batch_size(2)
1182 .input_size(13, 12)
1183 .padding_height(1)
1184 .kernel_size(3, kernel_width)
1185 .group_input_channels(17)
1186 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1187 .iterations(3)
1188 .TestQ8();
1189 }
1190}
1191
1192TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_height_padding) {
1193 ASSERT_EQ(xnn_status_success, xnn_initialize());
1194 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
1195 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
1196 DeconvolutionOperatorTester()
1197 .batch_size(2)
1198 .input_size(13, 12)
1199 .padding_width(1)
1200 .padding_top(padding_top)
1201 .padding_bottom(padding_bottom)
1202 .kernel_size(3, 3)
1203 .group_input_channels(15)
1204 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1205 .iterations(1)
1206 .TestQ8();
1207 }
1208 }
1209}
1210
1211TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_width_padding) {
1212 ASSERT_EQ(xnn_status_success, xnn_initialize());
1213 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
1214 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
1215 DeconvolutionOperatorTester()
1216 .batch_size(2)
1217 .input_size(13, 12)
1218 .padding_height(1)
1219 .padding_left(padding_left)
1220 .padding_right(padding_right)
1221 .kernel_size(3, 3)
1222 .group_input_channels(15)
1223 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1224 .iterations(1)
1225 .TestQ8();
1226 }
1227 }
1228}
1229
1230TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_height_adjustment) {
1231 ASSERT_EQ(xnn_status_success, xnn_initialize());
1232 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
1233 DeconvolutionOperatorTester()
1234 .batch_size(2)
1235 .input_size(13, 12)
1236 .padding(1)
1237 .adjustment_height(adjustment_height)
1238 .kernel_size(3, 3)
1239 .group_input_channels(15)
1240 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1241 .iterations(1)
1242 .TestQ8();
1243 }
1244}
1245
1246TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_width_adjustment) {
1247 ASSERT_EQ(xnn_status_success, xnn_initialize());
1248 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
1249 DeconvolutionOperatorTester()
1250 .batch_size(2)
1251 .input_size(13, 12)
1252 .padding(1)
1253 .adjustment_width(adjustment_width)
1254 .kernel_size(3, 3)
1255 .group_input_channels(15)
1256 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1257 .iterations(1)
1258 .TestQ8();
1259 }
1260}
1261
1262TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_input_height) {
1263 ASSERT_EQ(xnn_status_success, xnn_initialize());
1264 for (size_t input_height = 10; input_height <= 15; input_height++) {
1265 DeconvolutionOperatorTester()
1266 .batch_size(2)
1267 .input_size(input_height, 12)
1268 .padding(1)
1269 .kernel_size(3, 3)
1270 .group_input_channels(15)
1271 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1272 .iterations(1)
1273 .TestQ8();
1274 }
1275}
1276
1277TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_input_width) {
1278 ASSERT_EQ(xnn_status_success, xnn_initialize());
1279 for (size_t input_width = 9; input_width <= 14; input_width++) {
1280 DeconvolutionOperatorTester()
1281 .batch_size(2)
1282 .input_size(13, input_width)
1283 .padding(1)
1284 .kernel_size(3, 3)
1285 .group_input_channels(15)
1286 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1287 .iterations(1)
1288 .TestQ8();
1289 }
1290}
1291
1292TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_input_channels) {
1293 ASSERT_EQ(xnn_status_success, xnn_initialize());
1294 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
1295 DeconvolutionOperatorTester()
1296 .batch_size(2)
1297 .input_size(13, 12)
1298 .padding(1)
1299 .kernel_size(3, 3)
1300 .group_input_channels(input_channels)
1301 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1302 .iterations(1)
1303 .TestQ8();
1304 }
1305}
1306
1307TEST(DECONVOLUTION_OP_Q8, batched_3x3_varying_output_channels) {
1308 ASSERT_EQ(xnn_status_success, xnn_initialize());
1309 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
1310 DeconvolutionOperatorTester()
1311 .batch_size(2)
1312 .input_size(13, 12)
1313 .padding(1)
1314 .kernel_size(3, 3)
1315 .group_input_channels(23)
1316 .group_output_channels(output_channels)
1317 .iterations(1)
1318 .TestQ8();
1319 }
1320}
1321
1322TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_height_dilation) {
1323 ASSERT_EQ(xnn_status_success, xnn_initialize());
1324 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
1325 DeconvolutionOperatorTester()
1326 .batch_size(2)
1327 .input_size(13, 12)
1328 .padding(1)
1329 .kernel_size(3, 3)
1330 .dilation_height(dilation_height)
1331 .group_input_channels(23)
1332 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1333 .iterations(3)
1334 .TestQ8();
1335 }
1336}
1337
1338TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_width_dilation) {
1339 ASSERT_EQ(xnn_status_success, xnn_initialize());
1340 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
1341 DeconvolutionOperatorTester()
1342 .batch_size(2)
1343 .input_size(13, 12)
1344 .padding(1)
1345 .kernel_size(3, 3)
1346 .dilation_width(dilation_width)
1347 .group_input_channels(23)
1348 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1349 .iterations(3)
1350 .TestQ8();
1351 }
1352}
1353
1354TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_height_dilation_and_stride) {
1355 ASSERT_EQ(xnn_status_success, xnn_initialize());
1356 DeconvolutionOperatorTester()
1357 .batch_size(2)
1358 .input_size(10, 9)
1359 .padding(1)
1360 .kernel_size(3, 3)
1361 .dilation_height(3)
1362 .stride_height(2)
1363 .group_input_channels(23)
1364 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1365 .iterations(3)
1366 .TestQ8();
1367}
1368
1369TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_width_dilation_and_stride) {
1370 ASSERT_EQ(xnn_status_success, xnn_initialize());
1371 DeconvolutionOperatorTester()
1372 .batch_size(2)
1373 .input_size(10, 9)
1374 .padding(1)
1375 .kernel_size(3, 3)
1376 .dilation_width(3)
1377 .stride_width(2)
1378 .group_input_channels(23)
1379 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1380 .iterations(3)
1381 .TestQ8();
1382}
1383
1384TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_input_stride) {
1385 ASSERT_EQ(xnn_status_success, xnn_initialize());
1386 DeconvolutionOperatorTester()
1387 .batch_size(2)
1388 .input_size(13, 12)
1389 .padding(1)
1390 .kernel_size(3, 3)
1391 .group_input_channels(23)
1392 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1393 .input_pixel_stride(28)
1394 .iterations(3)
1395 .TestQ8();
1396}
1397
1398TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_output_stride) {
1399 ASSERT_EQ(xnn_status_success, xnn_initialize());
1400 DeconvolutionOperatorTester()
1401 .batch_size(2)
1402 .input_size(13, 12)
1403 .padding(1)
1404 .kernel_size(3, 3)
1405 .group_input_channels(23)
1406 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1407 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
1408 .iterations(3)
1409 .TestQ8();
1410}
1411
1412TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_qmin) {
1413 ASSERT_EQ(xnn_status_success, xnn_initialize());
1414 DeconvolutionOperatorTester()
1415 .batch_size(2)
1416 .input_size(13, 12)
1417 .padding(1)
1418 .kernel_size(3, 3)
1419 .group_input_channels(23)
1420 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1421 .qmin(128)
1422 .iterations(3)
1423 .TestQ8();
1424}
1425
1426TEST(DECONVOLUTION_OP_Q8, batched_3x3_with_qmax) {
1427 ASSERT_EQ(xnn_status_success, xnn_initialize());
1428 DeconvolutionOperatorTester()
1429 .batch_size(2)
1430 .input_size(13, 12)
1431 .padding(1)
1432 .kernel_size(3, 3)
1433 .group_input_channels(23)
1434 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1435 .qmin(128)
1436 .iterations(3)
1437 .TestQ8();
1438}
1439
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]1440TEST(DECONVOLUTION_OP_Q8, batched_3x3_without_bias) {
1441 ASSERT_EQ(xnn_status_success, xnn_initialize());
1442 DeconvolutionOperatorTester()
1443 .has_bias(false)
1444 .batch_size(2)
1445 .input_size(13, 12)
1446 .padding(1)
1447 .kernel_size(3, 3)
1448 .group_input_channels(23)
1449 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1450 .iterations(3)
1451 .TestQ8();
1452}
1453
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1454/**************************** CONV path, grouped, batched ****************************/
1455
1456TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3) {
1457 ASSERT_EQ(xnn_status_success, xnn_initialize());
1458 DeconvolutionOperatorTester()
1459 .batch_size(2)
1460 .input_size(13, 12)
1461 .padding(1)
1462 .kernel_size(3, 3)
1463 .groups(2)
1464 .group_input_channels(15)
1465 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1466 .iterations(3)
1467 .TestQ8();
1468}
1469
1470TEST(DECONVOLUTION_OP_Q8, batched_grouped_Kx3) {
1471 ASSERT_EQ(xnn_status_success, xnn_initialize());
1472 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
1473 DeconvolutionOperatorTester()
1474 .batch_size(2)
1475 .input_size(13, 12)
1476 .padding_width(1)
1477 .kernel_size(kernel_height, 3)
1478 .groups(2)
1479 .group_input_channels(17)
1480 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1481 .iterations(3)
1482 .TestQ8();
1483 }
1484}
1485
1486TEST(DECONVOLUTION_OP_Q8, batched_grouped_3xK) {
1487 ASSERT_EQ(xnn_status_success, xnn_initialize());
1488 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
1489 DeconvolutionOperatorTester()
1490 .batch_size(2)
1491 .input_size(13, 12)
1492 .padding_height(1)
1493 .kernel_size(3, kernel_width)
1494 .groups(2)
1495 .group_input_channels(17)
1496 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1497 .iterations(3)
1498 .TestQ8();
1499 }
1500}
1501
1502TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_height_padding) {
1503 ASSERT_EQ(xnn_status_success, xnn_initialize());
1504 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
1505 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
1506 DeconvolutionOperatorTester()
1507 .batch_size(2)
1508 .input_size(13, 12)
1509 .padding_width(1)
1510 .padding_top(padding_top)
1511 .padding_bottom(padding_bottom)
1512 .kernel_size(3, 3)
1513 .groups(2)
1514 .group_input_channels(15)
1515 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1516 .iterations(1)
1517 .TestQ8();
1518 }
1519 }
1520}
1521
1522TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_width_padding) {
1523 ASSERT_EQ(xnn_status_success, xnn_initialize());
1524 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
1525 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
1526 DeconvolutionOperatorTester()
1527 .batch_size(2)
1528 .input_size(13, 12)
1529 .padding_height(1)
1530 .padding_left(padding_left)
1531 .padding_right(padding_right)
1532 .kernel_size(3, 3)
1533 .groups(2)
1534 .group_input_channels(15)
1535 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1536 .iterations(1)
1537 .TestQ8();
1538 }
1539 }
1540}
1541
1542TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_height_adjustment) {
1543 ASSERT_EQ(xnn_status_success, xnn_initialize());
1544 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
1545 DeconvolutionOperatorTester()
1546 .batch_size(2)
1547 .input_size(13, 12)
1548 .padding(1)
1549 .adjustment_height(adjustment_height)
1550 .kernel_size(3, 3)
1551 .groups(2)
1552 .group_input_channels(15)
1553 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1554 .iterations(1)
1555 .TestQ8();
1556 }
1557}
1558
1559TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_width_adjustment) {
1560 ASSERT_EQ(xnn_status_success, xnn_initialize());
1561 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
1562 DeconvolutionOperatorTester()
1563 .batch_size(2)
1564 .input_size(13, 12)
1565 .padding(1)
1566 .adjustment_width(adjustment_width)
1567 .kernel_size(3, 3)
1568 .groups(2)
1569 .group_input_channels(15)
1570 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1571 .iterations(1)
1572 .TestQ8();
1573 }
1574}
1575
1576TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_input_height) {
1577 ASSERT_EQ(xnn_status_success, xnn_initialize());
1578 for (size_t input_height = 10; input_height <= 15; input_height++) {
1579 DeconvolutionOperatorTester()
1580 .batch_size(2)
1581 .input_size(input_height, 12)
1582 .padding(1)
1583 .kernel_size(3, 3)
1584 .groups(2)
1585 .group_input_channels(15)
1586 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1587 .iterations(1)
1588 .TestQ8();
1589 }
1590}
1591
1592TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_input_width) {
1593 ASSERT_EQ(xnn_status_success, xnn_initialize());
1594 for (size_t input_width = 9; input_width <= 14; input_width++) {
1595 DeconvolutionOperatorTester()
1596 .batch_size(2)
1597 .input_size(13, input_width)
1598 .padding(1)
1599 .kernel_size(3, 3)
1600 .groups(2)
1601 .group_input_channels(15)
1602 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1603 .iterations(1)
1604 .TestQ8();
1605 }
1606}
1607
1608TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_input_channels) {
1609 ASSERT_EQ(xnn_status_success, xnn_initialize());
1610 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
1611 DeconvolutionOperatorTester()
1612 .batch_size(2)
1613 .input_size(13, 12)
1614 .padding(1)
1615 .kernel_size(3, 3)
1616 .groups(2)
1617 .group_input_channels(input_channels)
1618 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1619 .iterations(1)
1620 .TestQ8();
1621 }
1622}
1623
1624TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_varying_output_channels) {
1625 ASSERT_EQ(xnn_status_success, xnn_initialize());
1626 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
1627 DeconvolutionOperatorTester()
1628 .batch_size(2)
1629 .input_size(13, 12)
1630 .padding(1)
1631 .kernel_size(3, 3)
1632 .groups(2)
1633 .group_input_channels(23)
1634 .group_output_channels(output_channels)
1635 .iterations(1)
1636 .TestQ8();
1637 }
1638}
1639
1640TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_height_dilation) {
1641 ASSERT_EQ(xnn_status_success, xnn_initialize());
1642 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
1643 DeconvolutionOperatorTester()
1644 .batch_size(2)
1645 .input_size(13, 12)
1646 .padding(1)
1647 .kernel_size(3, 3)
1648 .dilation_height(dilation_height)
1649 .groups(2)
1650 .group_input_channels(23)
1651 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1652 .iterations(3)
1653 .TestQ8();
1654 }
1655}
1656
1657TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_width_dilation) {
1658 ASSERT_EQ(xnn_status_success, xnn_initialize());
1659 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
1660 DeconvolutionOperatorTester()
1661 .batch_size(2)
1662 .input_size(13, 12)
1663 .padding(1)
1664 .kernel_size(3, 3)
1665 .dilation_width(dilation_width)
1666 .groups(2)
1667 .group_input_channels(23)
1668 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1669 .iterations(3)
1670 .TestQ8();
1671 }
1672}
1673
1674TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_height_dilation_and_stride) {
1675 ASSERT_EQ(xnn_status_success, xnn_initialize());
1676 DeconvolutionOperatorTester()
1677 .batch_size(2)
1678 .input_size(10, 9)
1679 .padding(1)
1680 .kernel_size(3, 3)
1681 .dilation_height(3)
1682 .stride_width(2)
1683 .groups(2)
1684 .group_input_channels(23)
1685 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1686 .iterations(3)
1687 .TestQ8();
1688}
1689
1690TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_width_dilation_and_stride) {
1691 ASSERT_EQ(xnn_status_success, xnn_initialize());
1692 DeconvolutionOperatorTester()
1693 .batch_size(2)
1694 .input_size(10, 9)
1695 .padding(1)
1696 .kernel_size(3, 3)
1697 .dilation_width(3)
1698 .stride_width(2)
1699 .groups(2)
1700 .group_input_channels(23)
1701 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1702 .iterations(3)
1703 .TestQ8();
1704}
1705
1706TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_input_stride) {
1707 ASSERT_EQ(xnn_status_success, xnn_initialize());
1708 DeconvolutionOperatorTester()
1709 .batch_size(2)
1710 .input_size(13, 12)
1711 .padding(1)
1712 .kernel_size(3, 3)
1713 .groups(2)
1714 .group_input_channels(23)
1715 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1716 .input_pixel_stride(47)
1717 .iterations(3)
1718 .TestQ8();
1719}
1720
1721TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_output_stride) {
1722 ASSERT_EQ(xnn_status_success, xnn_initialize());
1723 DeconvolutionOperatorTester()
1724 .batch_size(2)
1725 .input_size(13, 12)
1726 .padding(1)
1727 .kernel_size(3, 3)
1728 .groups(2)
1729 .group_input_channels(23)
1730 .group_output_channels(xnn_params.q8.gemm.nr + 3)
1731 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
1732 .iterations(3)
1733 .TestQ8();
1734}
1735
1736TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_qmin) {
1737 ASSERT_EQ(xnn_status_success, xnn_initialize());
1738 DeconvolutionOperatorTester()
1739 .batch_size(2)
1740 .input_size(13, 12)
1741 .padding(1)
1742 .kernel_size(3, 3)
1743 .groups(2)
1744 .group_input_channels(23)
1745 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1746 .qmin(128)
1747 .iterations(3)
1748 .TestQ8();
1749}
1750
1751TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_with_qmax) {
1752 ASSERT_EQ(xnn_status_success, xnn_initialize());
1753 DeconvolutionOperatorTester()
1754 .batch_size(2)
1755 .input_size(13, 12)
1756 .padding(1)
1757 .kernel_size(3, 3)
1758 .groups(2)
1759 .group_input_channels(23)
1760 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1761 .qmin(128)
1762 .iterations(3)
1763 .TestQ8();
1764}
1765
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]1766TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3_without_bias) {
1767 ASSERT_EQ(xnn_status_success, xnn_initialize());
1768 DeconvolutionOperatorTester()
1769 .has_bias(false)
1770 .batch_size(2)
1771 .input_size(13, 12)
1772 .padding(1)
1773 .kernel_size(3, 3)
1774 .groups(2)
1775 .group_input_channels(23)
1776 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1777 .iterations(3)
1778 .TestQ8();
1779}
1780
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1781/**************************** CONV path, setup ****************************/
1782
1783TEST(DECONVOLUTION_OP_Q8, 3x3_setup_changing_batch) {
1784 ASSERT_EQ(xnn_status_success, xnn_initialize());
1785 DeconvolutionOperatorTester()
1786 .batch_size(2)
1787 .next_batch_size(5)
1788 .input_height(12)
1789 .input_width(13)
1790 .kernel_height(3)
1791 .kernel_width(5)
1792 .groups(2)
1793 .group_input_channels(15)
1794 .group_output_channels(17)
1795 .TestSetupQ8();
1796}
1797
1798TEST(DECONVOLUTION_OP_Q8, 3x3_setup_changing_height) {
1799 ASSERT_EQ(xnn_status_success, xnn_initialize());
1800 DeconvolutionOperatorTester()
1801 .batch_size(2)
1802 .input_height(12)
1803 .input_width(13)
1804 .next_input_height(14)
1805 .kernel_height(3)
1806 .kernel_width(5)
1807 .groups(2)
1808 .group_input_channels(15)
1809 .group_output_channels(17)
1810 .TestSetupQ8();
1811}
1812
1813TEST(DECONVOLUTION_OP_Q8, 3x3_setup_changing_width) {
1814 ASSERT_EQ(xnn_status_success, xnn_initialize());
1815 DeconvolutionOperatorTester()
1816 .batch_size(2)
1817 .input_height(12)
1818 .input_width(13)
1819 .next_input_width(14)
1820 .kernel_height(3)
1821 .kernel_width(5)
1822 .groups(2)
1823 .group_input_channels(15)
1824 .group_output_channels(17)
1825 .TestSetupQ8();
1826}
1827
1828/**************************** SUBCONV2D path ****************************/
1829
1830TEST(DECONVOLUTION_OP_Q8, 3x3s2) {
1831 ASSERT_EQ(xnn_status_success, xnn_initialize());
1832 DeconvolutionOperatorTester()
1833 .input_size(10, 9)
1834 .padding(1)
1835 .kernel_size(3, 3)
1836 .stride(2)
1837 .group_input_channels(15)
1838 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1839 .iterations(3)
1840 .TestQ8();
1841}
1842
1843TEST(DECONVOLUTION_OP_Q8, Kx3s2) {
1844 ASSERT_EQ(xnn_status_success, xnn_initialize());
1845 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
1846 DeconvolutionOperatorTester()
1847 .input_size(10, 9)
1848 .padding_width(1)
1849 .kernel_size(kernel_height, 3)
1850 .stride(2)
1851 .group_input_channels(17)
1852 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1853 .iterations(3)
1854 .TestQ8();
1855 }
1856}
1857
1858TEST(DECONVOLUTION_OP_Q8, 3xKs2) {
1859 ASSERT_EQ(xnn_status_success, xnn_initialize());
1860 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
1861 DeconvolutionOperatorTester()
1862 .input_size(10, 9)
1863 .padding_height(1)
1864 .kernel_size(3, kernel_width)
1865 .stride(2)
1866 .group_input_channels(17)
1867 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1868 .iterations(3)
1869 .TestQ8();
1870 }
1871}
1872
1873TEST(DECONVOLUTION_OP_Q8, 3x3sSx1) {
1874 ASSERT_EQ(xnn_status_success, xnn_initialize());
1875 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
1876 DeconvolutionOperatorTester()
1877 .input_size(10, 9)
1878 .padding(1)
1879 .padding_width(1)
1880 .kernel_size(3, 3)
1881 .stride_height(stride_height)
1882 .group_input_channels(17)
1883 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1884 .iterations(3)
1885 .TestQ8();
1886 }
1887}
1888
1889TEST(DECONVOLUTION_OP_Q8, 3x3s1xS) {
1890 ASSERT_EQ(xnn_status_success, xnn_initialize());
1891 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
1892 DeconvolutionOperatorTester()
1893 .input_size(10, 9)
1894 .padding(1)
1895 .padding_width(1)
1896 .kernel_size(3, 3)
1897 .stride_width(stride_width)
1898 .group_input_channels(17)
1899 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1900 .iterations(3)
1901 .TestQ8();
1902 }
1903}
1904
1905TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_height_padding) {
1906 ASSERT_EQ(xnn_status_success, xnn_initialize());
1907 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
1908 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
1909 DeconvolutionOperatorTester()
1910 .input_size(10, 9)
1911 .padding_width(1)
1912 .padding_top(padding_top)
1913 .padding_bottom(padding_bottom)
1914 .kernel_size(3, 3)
1915 .stride(2)
1916 .group_input_channels(15)
1917 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1918 .iterations(1)
1919 .TestQ8();
1920 }
1921 }
1922}
1923
1924TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_width_padding) {
1925 ASSERT_EQ(xnn_status_success, xnn_initialize());
1926 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
1927 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
1928 DeconvolutionOperatorTester()
1929 .input_size(10, 9)
1930 .padding_height(1)
1931 .padding_left(padding_left)
1932 .padding_right(padding_right)
1933 .kernel_size(3, 3)
1934 .stride(2)
1935 .group_input_channels(15)
1936 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1937 .iterations(1)
1938 .TestQ8();
1939 }
1940 }
1941}
1942
1943TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_height_adjustment) {
1944 ASSERT_EQ(xnn_status_success, xnn_initialize());
1945 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
1946 DeconvolutionOperatorTester()
1947 .input_size(10, 9)
1948 .padding(1)
1949 .adjustment_height(adjustment_height)
1950 .kernel_size(3, 3)
1951 .stride(2)
1952 .group_input_channels(15)
1953 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1954 .iterations(1)
1955 .TestQ8();
1956 }
1957}
1958
1959TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_width_adjustment) {
1960 ASSERT_EQ(xnn_status_success, xnn_initialize());
1961 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
1962 DeconvolutionOperatorTester()
1963 .input_size(10, 9)
1964 .padding(1)
1965 .adjustment_width(adjustment_width)
1966 .kernel_size(3, 3)
1967 .stride(2)
1968 .group_input_channels(15)
1969 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1970 .iterations(1)
1971 .TestQ8();
1972 }
1973}
1974
1975TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_input_height) {
1976 ASSERT_EQ(xnn_status_success, xnn_initialize());
1977 for (size_t input_height = 8; input_height <= 12; input_height++) {
1978 DeconvolutionOperatorTester()
1979 .input_size(input_height, 9)
1980 .padding(1)
1981 .kernel_size(3, 3)
1982 .stride(2)
1983 .group_input_channels(15)
1984 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
1985 .iterations(1)
1986 .TestQ8();
1987 }
1988}
1989
1990TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_input_width) {
1991 ASSERT_EQ(xnn_status_success, xnn_initialize());
1992 for (size_t input_width = 7; input_width <= 11; input_width++) {
1993 DeconvolutionOperatorTester()
1994 .input_size(10, input_width)
1995 .padding(1)
1996 .kernel_size(3, 3)
1997 .stride(2)
1998 .group_input_channels(15)
1999 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2000 .iterations(1)
2001 .TestQ8();
2002 }
2003}
2004
2005TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_input_channels) {
2006 ASSERT_EQ(xnn_status_success, xnn_initialize());
2007 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
2008 DeconvolutionOperatorTester()
2009 .input_size(10, 9)
2010 .padding(1)
2011 .kernel_size(3, 3)
2012 .stride(2)
2013 .group_input_channels(input_channels)
2014 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2015 .iterations(1)
2016 .TestQ8();
2017 }
2018}
2019
2020TEST(DECONVOLUTION_OP_Q8, 3x3s2_varying_output_channels) {
2021 ASSERT_EQ(xnn_status_success, xnn_initialize());
2022 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
2023 DeconvolutionOperatorTester()
2024 .input_size(10, 9)
2025 .padding(1)
2026 .kernel_size(3, 3)
2027 .stride(2)
2028 .group_input_channels(23)
2029 .group_output_channels(output_channels)
2030 .iterations(1)
2031 .TestQ8();
2032 }
2033}
2034
2035TEST(DECONVOLUTION_OP_Q8, 3x3s2_with_input_stride) {
2036 ASSERT_EQ(xnn_status_success, xnn_initialize());
2037 DeconvolutionOperatorTester()
2038 .input_size(10, 9)
2039 .padding(1)
2040 .kernel_size(3, 3)
2041 .stride(2)
2042 .group_input_channels(23)
2043 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2044 .input_pixel_stride(28)
2045 .iterations(3)
2046 .TestQ8();
2047}
2048
2049TEST(DECONVOLUTION_OP_Q8, 3x3s2_with_output_stride) {
2050 ASSERT_EQ(xnn_status_success, xnn_initialize());
2051 DeconvolutionOperatorTester()
2052 .input_size(10, 9)
2053 .padding(1)
2054 .kernel_size(3, 3)
2055 .stride(2)
2056 .group_input_channels(23)
2057 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2058 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
2059 .iterations(3)
2060 .TestQ8();
2061}
2062
2063TEST(DECONVOLUTION_OP_Q8, 3x3s2_with_qmin) {
2064 ASSERT_EQ(xnn_status_success, xnn_initialize());
2065 DeconvolutionOperatorTester()
2066 .input_size(10, 9)
2067 .padding(1)
2068 .kernel_size(3, 3)
2069 .stride(2)
2070 .group_input_channels(23)
2071 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2072 .qmin(128)
2073 .iterations(3)
2074 .TestQ8();
2075}
2076
2077TEST(DECONVOLUTION_OP_Q8, 3x3s2_with_qmax) {
2078 ASSERT_EQ(xnn_status_success, xnn_initialize());
2079 DeconvolutionOperatorTester()
2080 .input_size(10, 9)
2081 .padding(1)
2082 .kernel_size(3, 3)
2083 .stride(2)
2084 .group_input_channels(23)
2085 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2086 .qmin(128)
2087 .iterations(3)
2088 .TestQ8();
2089}
2090
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]2091TEST(DECONVOLUTION_OP_Q8, 3x3s2_without_bias) {
2092 ASSERT_EQ(xnn_status_success, xnn_initialize());
2093 DeconvolutionOperatorTester()
2094 .has_bias(false)
2095 .input_size(10, 9)
2096 .padding(1)
2097 .kernel_size(3, 3)
2098 .stride(2)
2099 .group_input_channels(23)
2100 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2101 .iterations(3)
2102 .TestQ8();
2103}
2104
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2105/**************************** SUBCONV2D path, grouped ****************************/
2106
2107TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2) {
2108 ASSERT_EQ(xnn_status_success, xnn_initialize());
2109 DeconvolutionOperatorTester()
2110 .input_size(10, 9)
2111 .padding(1)
2112 .kernel_size(3, 3)
2113 .stride(2)
2114 .groups(2)
2115 .group_input_channels(17)
2116 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2117 .iterations(3)
2118 .TestQ8();
2119}
2120
2121TEST(DECONVOLUTION_OP_Q8, grouped_Kx3s2) {
2122 ASSERT_EQ(xnn_status_success, xnn_initialize());
2123 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
2124 DeconvolutionOperatorTester()
2125 .input_size(10, 9)
2126 .padding_width(1)
2127 .kernel_size(kernel_height, 3)
2128 .stride(2)
2129 .groups(2)
2130 .group_input_channels(17)
2131 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2132 .iterations(3)
2133 .TestQ8();
2134 }
2135}
2136
2137TEST(DECONVOLUTION_OP_Q8, grouped_3xKs2) {
2138 ASSERT_EQ(xnn_status_success, xnn_initialize());
2139 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
2140 DeconvolutionOperatorTester()
2141 .input_size(10, 9)
2142 .padding_height(1)
2143 .kernel_size(3, kernel_width)
2144 .stride(2)
2145 .groups(2)
2146 .group_input_channels(17)
2147 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2148 .iterations(3)
2149 .TestQ8();
2150 }
2151}
2152
2153TEST(DECONVOLUTION_OP_Q8, grouped_3x3sSx1) {
2154 ASSERT_EQ(xnn_status_success, xnn_initialize());
2155 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
2156 DeconvolutionOperatorTester()
2157 .input_size(10, 9)
2158 .padding(1)
2159 .padding_width(1)
2160 .kernel_size(3, 3)
2161 .stride_height(stride_height)
2162 .groups(2)
2163 .group_input_channels(17)
2164 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2165 .iterations(3)
2166 .TestQ8();
2167 }
2168}
2169
2170TEST(DECONVOLUTION_OP_Q8, grouped_3x3s1xS) {
2171 ASSERT_EQ(xnn_status_success, xnn_initialize());
2172 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
2173 DeconvolutionOperatorTester()
2174 .input_size(10, 9)
2175 .padding(1)
2176 .padding_width(1)
2177 .kernel_size(3, 3)
2178 .stride_width(stride_width)
2179 .groups(2)
2180 .group_input_channels(17)
2181 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2182 .iterations(3)
2183 .TestQ8();
2184 }
2185}
2186
2187TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_height_padding) {
2188 ASSERT_EQ(xnn_status_success, xnn_initialize());
2189 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
2190 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
2191 DeconvolutionOperatorTester()
2192 .input_size(10, 9)
2193 .padding_width(1)
2194 .padding_top(padding_top)
2195 .padding_bottom(padding_bottom)
2196 .kernel_size(3, 3)
2197 .stride(2)
2198 .groups(2)
2199 .group_input_channels(17)
2200 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2201 .iterations(1)
2202 .TestQ8();
2203 }
2204 }
2205}
2206
2207TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_width_padding) {
2208 ASSERT_EQ(xnn_status_success, xnn_initialize());
2209 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
2210 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
2211 DeconvolutionOperatorTester()
2212 .input_size(10, 9)
2213 .padding_height(1)
2214 .padding_left(padding_left)
2215 .padding_right(padding_right)
2216 .kernel_size(3, 3)
2217 .stride(2)
2218 .groups(2)
2219 .group_input_channels(17)
2220 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2221 .iterations(1)
2222 .TestQ8();
2223 }
2224 }
2225}
2226
2227TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_height_adjustment) {
2228 ASSERT_EQ(xnn_status_success, xnn_initialize());
2229 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
2230 DeconvolutionOperatorTester()
2231 .input_size(10, 9)
2232 .padding(1)
2233 .adjustment_height(adjustment_height)
2234 .kernel_size(3, 3)
2235 .stride(2)
2236 .groups(2)
2237 .group_input_channels(17)
2238 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2239 .iterations(1)
2240 .TestQ8();
2241 }
2242}
2243
2244TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_width_adjustment) {
2245 ASSERT_EQ(xnn_status_success, xnn_initialize());
2246 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
2247 DeconvolutionOperatorTester()
2248 .input_size(10, 9)
2249 .padding(1)
2250 .adjustment_width(adjustment_width)
2251 .kernel_size(3, 3)
2252 .stride(2)
2253 .groups(2)
2254 .group_input_channels(17)
2255 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2256 .iterations(1)
2257 .TestQ8();
2258 }
2259}
2260
2261TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_input_height) {
2262 ASSERT_EQ(xnn_status_success, xnn_initialize());
2263 for (size_t input_height = 8; input_height <= 12; input_height++) {
2264 DeconvolutionOperatorTester()
2265 .input_size(input_height, 9)
2266 .padding(1)
2267 .kernel_size(3, 3)
2268 .stride(2)
2269 .groups(2)
2270 .group_input_channels(17)
2271 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2272 .iterations(1)
2273 .TestQ8();
2274 }
2275}
2276
2277TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_input_width) {
2278 ASSERT_EQ(xnn_status_success, xnn_initialize());
2279 for (size_t input_width = 7; input_width <= 11; input_width++) {
2280 DeconvolutionOperatorTester()
2281 .input_size(10, input_width)
2282 .padding(1)
2283 .kernel_size(3, 3)
2284 .stride(2)
2285 .groups(2)
2286 .group_input_channels(17)
2287 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2288 .iterations(1)
2289 .TestQ8();
2290 }
2291}
2292
2293TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_input_channels) {
2294 ASSERT_EQ(xnn_status_success, xnn_initialize());
2295 for (size_t input_channels = 14; input_channels <= 20; input_channels++) {
2296 DeconvolutionOperatorTester()
2297 .input_size(10, 9)
2298 .padding(1)
2299 .kernel_size(3, 3)
2300 .stride(2)
2301 .groups(2)
2302 .group_input_channels(input_channels)
2303 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2304 .iterations(1)
2305 .TestQ8();
2306 }
2307}
2308
2309TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_varying_output_channels) {
2310 ASSERT_EQ(xnn_status_success, xnn_initialize());
2311 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
2312 DeconvolutionOperatorTester()
2313 .input_size(10, 9)
2314 .padding(1)
2315 .kernel_size(3, 3)
2316 .stride(2)
2317 .groups(2)
2318 .group_input_channels(17)
2319 .group_output_channels(output_channels)
2320 .iterations(1)
2321 .TestQ8();
2322 }
2323}
2324
2325TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_with_input_stride) {
2326 ASSERT_EQ(xnn_status_success, xnn_initialize());
2327 DeconvolutionOperatorTester()
2328 .input_size(10, 9)
2329 .padding(1)
2330 .kernel_size(3, 3)
2331 .stride(2)
2332 .groups(2)
2333 .group_input_channels(17)
2334 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2335 .input_pixel_stride(37)
2336 .iterations(3)
2337 .TestQ8();
2338}
2339
2340TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_with_output_stride) {
2341 ASSERT_EQ(xnn_status_success, xnn_initialize());
2342 DeconvolutionOperatorTester()
2343 .input_size(10, 9)
2344 .padding(1)
2345 .kernel_size(3, 3)
2346 .stride(2)
2347 .groups(2)
2348 .group_input_channels(17)
2349 .group_output_channels(xnn_params.q8.gemm.nr + 3)
2350 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
2351 .iterations(3)
2352 .TestQ8();
2353}
2354
2355TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_with_qmin) {
2356 ASSERT_EQ(xnn_status_success, xnn_initialize());
2357 DeconvolutionOperatorTester()
2358 .input_size(10, 9)
2359 .padding(1)
2360 .kernel_size(3, 3)
2361 .stride(2)
2362 .groups(2)
2363 .group_input_channels(17)
2364 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2365 .qmin(128)
2366 .iterations(3)
2367 .TestQ8();
2368}
2369
2370TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_with_qmax) {
2371 ASSERT_EQ(xnn_status_success, xnn_initialize());
2372 DeconvolutionOperatorTester()
2373 .input_size(10, 9)
2374 .padding(1)
2375 .kernel_size(3, 3)
2376 .stride(2)
2377 .groups(2)
2378 .group_input_channels(17)
2379 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2380 .qmin(128)
2381 .iterations(3)
2382 .TestQ8();
2383}
2384
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]2385TEST(DECONVOLUTION_OP_Q8, grouped_3x3s2_without_bias) {
2386 ASSERT_EQ(xnn_status_success, xnn_initialize());
2387 DeconvolutionOperatorTester()
2388 .has_bias(false)
2389 .input_size(10, 9)
2390 .padding(1)
2391 .kernel_size(3, 3)
2392 .stride(2)
2393 .groups(2)
2394 .group_input_channels(17)
2395 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2396 .iterations(3)
2397 .TestQ8();
2398}
2399
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2400/**************************** SUBCONV2D path, batched ****************************/
2401
2402TEST(DECONVOLUTION_OP_Q8, batched_3x3s2) {
2403 ASSERT_EQ(xnn_status_success, xnn_initialize());
2404 DeconvolutionOperatorTester()
2405 .batch_size(2)
2406 .input_size(10, 9)
2407 .padding(1)
2408 .kernel_size(3, 3)
2409 .stride(2)
2410 .group_input_channels(15)
2411 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2412 .iterations(3)
2413 .TestQ8();
2414}
2415
2416TEST(DECONVOLUTION_OP_Q8, batched_Kx3s2) {
2417 ASSERT_EQ(xnn_status_success, xnn_initialize());
2418 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
2419 DeconvolutionOperatorTester()
2420 .batch_size(2)
2421 .input_size(10, 9)
2422 .padding_width(1)
2423 .kernel_size(kernel_height, 3)
2424 .stride(2)
2425 .group_input_channels(17)
2426 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2427 .iterations(3)
2428 .TestQ8();
2429 }
2430}
2431
2432TEST(DECONVOLUTION_OP_Q8, batched_3xKs2) {
2433 ASSERT_EQ(xnn_status_success, xnn_initialize());
2434 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
2435 DeconvolutionOperatorTester()
2436 .batch_size(2)
2437 .input_size(10, 9)
2438 .padding_height(1)
2439 .kernel_size(3, kernel_width)
2440 .stride(2)
2441 .group_input_channels(17)
2442 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2443 .iterations(3)
2444 .TestQ8();
2445 }
2446}
2447
2448TEST(DECONVOLUTION_OP_Q8, batched_3x3sSx1) {
2449 ASSERT_EQ(xnn_status_success, xnn_initialize());
2450 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
2451 DeconvolutionOperatorTester()
2452 .batch_size(2)
2453 .input_size(10, 9)
2454 .padding(1)
2455 .padding_width(1)
2456 .kernel_size(3, 3)
2457 .stride_height(stride_height)
2458 .group_input_channels(17)
2459 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2460 .iterations(3)
2461 .TestQ8();
2462 }
2463}
2464
2465TEST(DECONVOLUTION_OP_Q8, batched_3x3s1xS) {
2466 ASSERT_EQ(xnn_status_success, xnn_initialize());
2467 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
2468 DeconvolutionOperatorTester()
2469 .batch_size(2)
2470 .input_size(10, 9)
2471 .padding(1)
2472 .padding_width(1)
2473 .kernel_size(3, 3)
2474 .stride_width(stride_width)
2475 .group_input_channels(17)
2476 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2477 .iterations(3)
2478 .TestQ8();
2479 }
2480}
2481
2482TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_height_padding) {
2483 ASSERT_EQ(xnn_status_success, xnn_initialize());
2484 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
2485 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
2486 DeconvolutionOperatorTester()
2487 .batch_size(2)
2488 .input_size(10, 9)
2489 .padding_width(1)
2490 .padding_top(padding_top)
2491 .padding_bottom(padding_bottom)
2492 .kernel_size(3, 3)
2493 .stride(2)
2494 .group_input_channels(15)
2495 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2496 .iterations(1)
2497 .TestQ8();
2498 }
2499 }
2500}
2501
2502TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_width_padding) {
2503 ASSERT_EQ(xnn_status_success, xnn_initialize());
2504 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
2505 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
2506 DeconvolutionOperatorTester()
2507 .batch_size(2)
2508 .input_size(10, 9)
2509 .padding_height(1)
2510 .padding_left(padding_left)
2511 .padding_right(padding_right)
2512 .kernel_size(3, 3)
2513 .stride(2)
2514 .group_input_channels(15)
2515 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2516 .iterations(1)
2517 .TestQ8();
2518 }
2519 }
2520}
2521
2522TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_height_adjustment) {
2523 ASSERT_EQ(xnn_status_success, xnn_initialize());
2524 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
2525 DeconvolutionOperatorTester()
2526 .batch_size(2)
2527 .input_size(10, 9)
2528 .padding(1)
2529 .adjustment_height(adjustment_height)
2530 .kernel_size(3, 3)
2531 .stride(2)
2532 .group_input_channels(15)
2533 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2534 .iterations(1)
2535 .TestQ8();
2536 }
2537}
2538
2539TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_width_adjustment) {
2540 ASSERT_EQ(xnn_status_success, xnn_initialize());
2541 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
2542 DeconvolutionOperatorTester()
2543 .batch_size(2)
2544 .input_size(10, 9)
2545 .padding(1)
2546 .adjustment_width(adjustment_width)
2547 .kernel_size(3, 3)
2548 .stride(2)
2549 .group_input_channels(15)
2550 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2551 .iterations(1)
2552 .TestQ8();
2553 }
2554}
2555
2556TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_input_height) {
2557 ASSERT_EQ(xnn_status_success, xnn_initialize());
2558 for (size_t input_height = 8; input_height <= 12; input_height++) {
2559 DeconvolutionOperatorTester()
2560 .batch_size(2)
2561 .input_size(input_height, 9)
2562 .padding(1)
2563 .kernel_size(3, 3)
2564 .stride(2)
2565 .group_input_channels(15)
2566 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2567 .iterations(1)
2568 .TestQ8();
2569 }
2570}
2571
2572TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_input_width) {
2573 ASSERT_EQ(xnn_status_success, xnn_initialize());
2574 for (size_t input_width = 7; input_width <= 11; input_width++) {
2575 DeconvolutionOperatorTester()
2576 .batch_size(2)
2577 .input_size(10, input_width)
2578 .padding(1)
2579 .kernel_size(3, 3)
2580 .stride(2)
2581 .group_input_channels(15)
2582 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2583 .iterations(1)
2584 .TestQ8();
2585 }
2586}
2587
2588TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_input_channels) {
2589 ASSERT_EQ(xnn_status_success, xnn_initialize());
2590 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
2591 DeconvolutionOperatorTester()
2592 .batch_size(2)
2593 .input_size(10, 9)
2594 .padding(1)
2595 .kernel_size(3, 3)
2596 .stride(2)
2597 .group_input_channels(input_channels)
2598 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2599 .iterations(1)
2600 .TestQ8();
2601 }
2602}
2603
2604TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_varying_output_channels) {
2605 ASSERT_EQ(xnn_status_success, xnn_initialize());
2606 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
2607 DeconvolutionOperatorTester()
2608 .batch_size(2)
2609 .input_size(10, 9)
2610 .padding(1)
2611 .kernel_size(3, 3)
2612 .stride(2)
2613 .group_input_channels(23)
2614 .group_output_channels(output_channels)
2615 .iterations(1)
2616 .TestQ8();
2617 }
2618}
2619
2620TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_with_input_stride) {
2621 ASSERT_EQ(xnn_status_success, xnn_initialize());
2622 DeconvolutionOperatorTester()
2623 .batch_size(2)
2624 .input_size(10, 9)
2625 .padding(1)
2626 .kernel_size(3, 3)
2627 .stride(2)
2628 .group_input_channels(23)
2629 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2630 .input_pixel_stride(28)
2631 .iterations(3)
2632 .TestQ8();
2633}
2634
2635TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_with_output_stride) {
2636 ASSERT_EQ(xnn_status_success, xnn_initialize());
2637 DeconvolutionOperatorTester()
2638 .batch_size(2)
2639 .input_size(10, 9)
2640 .padding(1)
2641 .kernel_size(3, 3)
2642 .stride(2)
2643 .group_input_channels(23)
2644 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2645 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
2646 .iterations(3)
2647 .TestQ8();
2648}
2649
2650TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_with_qmin) {
2651 ASSERT_EQ(xnn_status_success, xnn_initialize());
2652 DeconvolutionOperatorTester()
2653 .batch_size(2)
2654 .input_size(10, 9)
2655 .padding(1)
2656 .kernel_size(3, 3)
2657 .stride(2)
2658 .group_input_channels(23)
2659 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2660 .qmin(128)
2661 .iterations(3)
2662 .TestQ8();
2663}
2664
2665TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_with_qmax) {
2666 ASSERT_EQ(xnn_status_success, xnn_initialize());
2667 DeconvolutionOperatorTester()
2668 .batch_size(2)
2669 .input_size(10, 9)
2670 .padding(1)
2671 .kernel_size(3, 3)
2672 .stride(2)
2673 .group_input_channels(23)
2674 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2675 .qmin(128)
2676 .iterations(3)
2677 .TestQ8();
2678}
2679
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]2680TEST(DECONVOLUTION_OP_Q8, batched_3x3s2_without_bias) {
2681 ASSERT_EQ(xnn_status_success, xnn_initialize());
2682 DeconvolutionOperatorTester()
2683 .has_bias(false)
2684 .batch_size(2)
2685 .input_size(10, 9)
2686 .padding(1)
2687 .kernel_size(3, 3)
2688 .stride(2)
2689 .group_input_channels(23)
2690 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2691 .iterations(3)
2692 .TestQ8();
2693}
2694
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2695/**************************** SUBCONV2D path, grouped, batched ****************************/
2696
2697TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2) {
2698 ASSERT_EQ(xnn_status_success, xnn_initialize());
2699 DeconvolutionOperatorTester()
2700 .batch_size(2)
2701 .input_size(10, 9)
2702 .padding(1)
2703 .kernel_size(3, 3)
2704 .stride(2)
2705 .groups(2)
2706 .group_input_channels(17)
2707 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2708 .iterations(3)
2709 .TestQ8();
2710}
2711
2712TEST(DECONVOLUTION_OP_Q8, batched_grouped_Kx3s2) {
2713 ASSERT_EQ(xnn_status_success, xnn_initialize());
2714 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
2715 DeconvolutionOperatorTester()
2716 .batch_size(2)
2717 .input_size(10, 9)
2718 .padding_width(1)
2719 .kernel_size(kernel_height, 3)
2720 .stride(2)
2721 .groups(2)
2722 .group_input_channels(17)
2723 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2724 .iterations(3)
2725 .TestQ8();
2726 }
2727}
2728
2729TEST(DECONVOLUTION_OP_Q8, batched_grouped_3xKs2) {
2730 ASSERT_EQ(xnn_status_success, xnn_initialize());
2731 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
2732 DeconvolutionOperatorTester()
2733 .batch_size(2)
2734 .input_size(10, 9)
2735 .padding_height(1)
2736 .kernel_size(3, kernel_width)
2737 .stride(2)
2738 .groups(2)
2739 .group_input_channels(17)
2740 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2741 .iterations(3)
2742 .TestQ8();
2743 }
2744}
2745
2746TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3sSx1) {
2747 ASSERT_EQ(xnn_status_success, xnn_initialize());
2748 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
2749 DeconvolutionOperatorTester()
2750 .batch_size(2)
2751 .input_size(10, 9)
2752 .padding(1)
2753 .padding_width(1)
2754 .kernel_size(3, 3)
2755 .stride_height(stride_height)
2756 .groups(2)
2757 .group_input_channels(17)
2758 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2759 .iterations(3)
2760 .TestQ8();
2761 }
2762}
2763
2764TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s1xS) {
2765 ASSERT_EQ(xnn_status_success, xnn_initialize());
2766 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
2767 DeconvolutionOperatorTester()
2768 .batch_size(2)
2769 .input_size(10, 9)
2770 .padding(1)
2771 .padding_width(1)
2772 .kernel_size(3, 3)
2773 .stride_width(stride_width)
2774 .groups(2)
2775 .group_input_channels(17)
2776 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2777 .iterations(3)
2778 .TestQ8();
2779 }
2780}
2781
2782TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_height_padding) {
2783 ASSERT_EQ(xnn_status_success, xnn_initialize());
2784 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
2785 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
2786 DeconvolutionOperatorTester()
2787 .batch_size(2)
2788 .input_size(10, 9)
2789 .padding_width(1)
2790 .padding_top(padding_top)
2791 .padding_bottom(padding_bottom)
2792 .kernel_size(3, 3)
2793 .stride(2)
2794 .groups(2)
2795 .group_input_channels(17)
2796 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2797 .iterations(1)
2798 .TestQ8();
2799 }
2800 }
2801}
2802
2803TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_width_padding) {
2804 ASSERT_EQ(xnn_status_success, xnn_initialize());
2805 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
2806 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
2807 DeconvolutionOperatorTester()
2808 .batch_size(2)
2809 .input_size(10, 9)
2810 .padding_height(1)
2811 .padding_left(padding_left)
2812 .padding_right(padding_right)
2813 .kernel_size(3, 3)
2814 .stride(2)
2815 .groups(2)
2816 .group_input_channels(17)
2817 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2818 .iterations(1)
2819 .TestQ8();
2820 }
2821 }
2822}
2823
2824TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_height_adjustment) {
2825 ASSERT_EQ(xnn_status_success, xnn_initialize());
2826 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
2827 DeconvolutionOperatorTester()
2828 .batch_size(2)
2829 .input_size(10, 9)
2830 .padding(1)
2831 .adjustment_height(adjustment_height)
2832 .kernel_size(3, 3)
2833 .stride(2)
2834 .groups(2)
2835 .group_input_channels(17)
2836 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2837 .iterations(1)
2838 .TestQ8();
2839 }
2840}
2841
2842TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_width_adjustment) {
2843 ASSERT_EQ(xnn_status_success, xnn_initialize());
2844 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
2845 DeconvolutionOperatorTester()
2846 .batch_size(2)
2847 .input_size(10, 9)
2848 .padding(1)
2849 .adjustment_width(adjustment_width)
2850 .kernel_size(3, 3)
2851 .stride(2)
2852 .groups(2)
2853 .group_input_channels(17)
2854 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2855 .iterations(1)
2856 .TestQ8();
2857 }
2858}
2859
2860TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_input_height) {
2861 ASSERT_EQ(xnn_status_success, xnn_initialize());
2862 for (size_t input_height = 8; input_height <= 12; input_height++) {
2863 DeconvolutionOperatorTester()
2864 .batch_size(2)
2865 .input_size(input_height, 9)
2866 .padding(1)
2867 .kernel_size(3, 3)
2868 .stride(2)
2869 .groups(2)
2870 .group_input_channels(17)
2871 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2872 .iterations(1)
2873 .TestQ8();
2874 }
2875}
2876
2877TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_input_width) {
2878 ASSERT_EQ(xnn_status_success, xnn_initialize());
2879 for (size_t input_width = 7; input_width <= 11; input_width++) {
2880 DeconvolutionOperatorTester()
2881 .batch_size(2)
2882 .input_size(10, input_width)
2883 .padding(1)
2884 .kernel_size(3, 3)
2885 .stride(2)
2886 .groups(2)
2887 .group_input_channels(17)
2888 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2889 .iterations(1)
2890 .TestQ8();
2891 }
2892}
2893
2894TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_input_channels) {
2895 ASSERT_EQ(xnn_status_success, xnn_initialize());
2896 for (size_t input_channels = 14; input_channels <= 20; input_channels++) {
2897 DeconvolutionOperatorTester()
2898 .batch_size(2)
2899 .input_size(10, 9)
2900 .padding(1)
2901 .kernel_size(3, 3)
2902 .stride(2)
2903 .groups(2)
2904 .group_input_channels(input_channels)
2905 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2906 .iterations(1)
2907 .TestQ8();
2908 }
2909}
2910
2911TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_varying_output_channels) {
2912 ASSERT_EQ(xnn_status_success, xnn_initialize());
2913 for (size_t output_channels = 1; output_channels <= xnn_params.q8.gemm.nr * 2; output_channels *= 2) {
2914 DeconvolutionOperatorTester()
2915 .batch_size(2)
2916 .input_size(10, 9)
2917 .padding(1)
2918 .kernel_size(3, 3)
2919 .stride(2)
2920 .groups(2)
2921 .group_input_channels(17)
2922 .group_output_channels(output_channels)
2923 .iterations(1)
2924 .TestQ8();
2925 }
2926}
2927
2928TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_with_input_stride) {
2929 ASSERT_EQ(xnn_status_success, xnn_initialize());
2930 DeconvolutionOperatorTester()
2931 .batch_size(2)
2932 .input_size(10, 9)
2933 .padding(1)
2934 .kernel_size(3, 3)
2935 .stride(2)
2936 .groups(2)
2937 .group_input_channels(17)
2938 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2939 .input_pixel_stride(37)
2940 .iterations(3)
2941 .TestQ8();
2942}
2943
2944TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_with_output_stride) {
2945 ASSERT_EQ(xnn_status_success, xnn_initialize());
2946 DeconvolutionOperatorTester()
2947 .batch_size(2)
2948 .input_size(10, 9)
2949 .padding(1)
2950 .kernel_size(3, 3)
2951 .stride(2)
2952 .groups(2)
2953 .group_input_channels(17)
2954 .group_output_channels(xnn_params.q8.gemm.nr + 3)
2955 .output_pixel_stride(xnn_params.q8.gemm.nr * 2 + 13)
2956 .iterations(3)
2957 .TestQ8();
2958}
2959
2960TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_with_qmin) {
2961 ASSERT_EQ(xnn_status_success, xnn_initialize());
2962 DeconvolutionOperatorTester()
2963 .batch_size(2)
2964 .input_size(10, 9)
2965 .padding(1)
2966 .kernel_size(3, 3)
2967 .stride(2)
2968 .groups(2)
2969 .group_input_channels(17)
2970 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2971 .qmin(128)
2972 .iterations(3)
2973 .TestQ8();
2974}
2975
2976TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_with_qmax) {
2977 ASSERT_EQ(xnn_status_success, xnn_initialize());
2978 DeconvolutionOperatorTester()
2979 .batch_size(2)
2980 .input_size(10, 9)
2981 .padding(1)
2982 .kernel_size(3, 3)
2983 .stride(2)
2984 .groups(2)
2985 .group_input_channels(17)
2986 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
2987 .qmin(128)
2988 .iterations(3)
2989 .TestQ8();
2990}
2991
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]2992TEST(DECONVOLUTION_OP_Q8, batched_grouped_3x3s2_without_bias) {
2993 ASSERT_EQ(xnn_status_success, xnn_initialize());
2994 DeconvolutionOperatorTester()
2995 .has_bias(false)
2996 .batch_size(2)
2997 .input_size(10, 9)
2998 .padding(1)
2999 .kernel_size(3, 3)
3000 .stride(2)
3001 .groups(2)
3002 .group_input_channels(17)
3003 .group_output_channels(xnn_params.q8.gemm.nr * 2 + 3)
3004 .iterations(3)
3005 .TestQ8();
3006}
3007
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3008/**************************** SUBCONV2D path, setup ****************************/
3009
3010TEST(DECONVOLUTION_OP_Q8, 3x3s2_setup_changing_batch) {
3011 ASSERT_EQ(xnn_status_success, xnn_initialize());
3012 DeconvolutionOperatorTester()
3013 .batch_size(2)
3014 .next_batch_size(5)
3015 .input_height(8)
3016 .input_width(9)
3017 .kernel_height(3)
3018 .kernel_width(5)
3019 .stride(2)
3020 .groups(2)
3021 .group_input_channels(15)
3022 .group_output_channels(17)
3023 .TestSetupQ8();
3024}
3025
3026TEST(DECONVOLUTION_OP_Q8, 3x3s2_setup_changing_height) {
3027 ASSERT_EQ(xnn_status_success, xnn_initialize());
3028 DeconvolutionOperatorTester()
3029 .batch_size(2)
3030 .input_height(8)
3031 .input_width(9)
3032 .next_input_height(10)
3033 .kernel_height(3)
3034 .kernel_width(5)
3035 .stride(2)
3036 .groups(2)
3037 .group_input_channels(15)
3038 .group_output_channels(17)
3039 .TestSetupQ8();
3040}
3041
3042TEST(DECONVOLUTION_OP_Q8, 3x3s2_setup_changing_width) {
3043 ASSERT_EQ(xnn_status_success, xnn_initialize());
3044 DeconvolutionOperatorTester()
3045 .batch_size(2)
3046 .input_height(8)
3047 .input_width(9)
3048 .next_input_width(10)
3049 .kernel_height(3)
3050 .kernel_width(5)
3051 .stride(2)
3052 .groups(2)
3053 .group_input_channels(15)
3054 .group_output_channels(17)
3055 .TestSetupQ8();
3056}
3057
3058/**************************** Future GEMM path ****************************/
3059
3060TEST(DECONVOLUTION_OP_F32, 1x1) {
3061 ASSERT_EQ(xnn_status_success, xnn_initialize());
3062 DeconvolutionOperatorTester()
3063 .input_size(27, 29)
3064 .kernel_size(1, 1)
3065 .group_input_channels(23)
3066 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3067 .iterations(3)
3068 .TestF32();
3069}
3070
3071TEST(DECONVOLUTION_OP_F32, 1x1_varying_input_width) {
3072 ASSERT_EQ(xnn_status_success, xnn_initialize());
3073 for (size_t input_width = 25; input_width <= 31; input_width++) {
3074 DeconvolutionOperatorTester()
3075 .input_size(input_width, 29)
3076 .kernel_size(1, 1)
3077 .group_input_channels(23)
3078 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3079 .iterations(1)
3080 .TestF32();
3081 }
3082}
3083
3084TEST(DECONVOLUTION_OP_F32, 1x1_varying_input_height) {
3085 ASSERT_EQ(xnn_status_success, xnn_initialize());
3086 for (size_t input_height = 27; input_height <= 33; input_height++) {
3087 DeconvolutionOperatorTester()
3088 .input_size(27, input_height)
3089 .kernel_size(1, 1)
3090 .group_input_channels(23)
3091 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3092 .iterations(1)
3093 .TestF32();
3094 }
3095}
3096
3097TEST(DECONVOLUTION_OP_F32, 1x1_varying_input_channels) {
3098 ASSERT_EQ(xnn_status_success, xnn_initialize());
3099 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
3100 DeconvolutionOperatorTester()
3101 .input_size(27, 29)
3102 .kernel_size(1, 1)
3103 .group_input_channels(input_channels)
3104 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3105 .iterations(1)
3106 .TestF32();
3107 }
3108}
3109
3110TEST(DECONVOLUTION_OP_F32, 1x1_varying_output_channels) {
3111 ASSERT_EQ(xnn_status_success, xnn_initialize());
3112 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
3113 DeconvolutionOperatorTester()
3114 .input_size(27, 29)
3115 .kernel_size(1, 1)
3116 .group_input_channels(23)
3117 .group_output_channels(output_channels)
3118 .iterations(1)
3119 .TestF32();
3120 }
3121}
3122
3123TEST(DECONVOLUTION_OP_F32, 1x1_with_input_stride) {
3124 ASSERT_EQ(xnn_status_success, xnn_initialize());
3125 DeconvolutionOperatorTester()
3126 .input_size(27, 29)
3127 .kernel_size(1, 1)
3128 .group_input_channels(23)
3129 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3130 .input_pixel_stride(28)
3131 .iterations(3)
3132 .TestF32();
3133}
3134
3135TEST(DECONVOLUTION_OP_F32, 1x1_with_output_stride) {
3136 ASSERT_EQ(xnn_status_success, xnn_initialize());
3137 DeconvolutionOperatorTester()
3138 .input_size(27, 29)
3139 .kernel_size(1, 1)
3140 .group_input_channels(23)
3141 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3142 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
3143 .iterations(3)
3144 .TestF32();
3145}
3146
3147TEST(DECONVOLUTION_OP_F32, 1x1_with_qmin) {
3148 ASSERT_EQ(xnn_status_success, xnn_initialize());
3149 DeconvolutionOperatorTester()
3150 .input_size(27, 29)
3151 .kernel_size(1, 1)
3152 .group_input_channels(23)
3153 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3154 .qmin(128)
3155 .iterations(3)
3156 .TestF32();
3157}
3158
3159TEST(DECONVOLUTION_OP_F32, 1x1_with_qmax) {
3160 ASSERT_EQ(xnn_status_success, xnn_initialize());
3161 DeconvolutionOperatorTester()
3162 .input_size(27, 29)
3163 .kernel_size(1, 1)
3164 .group_input_channels(23)
3165 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3166 .qmin(128)
3167 .iterations(3)
3168 .TestF32();
3169}
3170
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]3171TEST(DECONVOLUTION_OP_F32, 1x1_without_bias) {
3172 ASSERT_EQ(xnn_status_success, xnn_initialize());
3173 DeconvolutionOperatorTester()
3174 .has_bias(false)
3175 .input_size(27, 29)
3176 .kernel_size(1, 1)
3177 .group_input_channels(23)
3178 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3179 .iterations(3)
3180 .TestF32();
3181}
3182
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3183/**************************** Future GEMM path, grouped ****************************/
3184
3185TEST(DECONVOLUTION_OP_F32, grouped_1x1) {
3186 ASSERT_EQ(xnn_status_success, xnn_initialize());
3187 DeconvolutionOperatorTester()
3188 .input_size(27, 29)
3189 .kernel_size(1, 1)
3190 .groups(2)
3191 .group_input_channels(23)
3192 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3193 .iterations(3)
3194 .TestF32();
3195}
3196
3197TEST(DECONVOLUTION_OP_F32, grouped_1x1_varying_input_width) {
3198 ASSERT_EQ(xnn_status_success, xnn_initialize());
3199 for (size_t input_width = 25; input_width <= 31; input_width++) {
3200 DeconvolutionOperatorTester()
3201 .input_size(input_width, 29)
3202 .kernel_size(1, 1)
3203 .groups(2)
3204 .group_input_channels(23)
3205 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3206 .iterations(1)
3207 .TestF32();
3208 }
3209}
3210
3211TEST(DECONVOLUTION_OP_F32, grouped_1x1_varying_input_height) {
3212 ASSERT_EQ(xnn_status_success, xnn_initialize());
3213 for (size_t input_height = 27; input_height <= 33; input_height++) {
3214 DeconvolutionOperatorTester()
3215 .input_size(27, input_height)
3216 .kernel_size(1, 1)
3217 .groups(2)
3218 .group_input_channels(23)
3219 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3220 .iterations(1)
3221 .TestF32();
3222 }
3223}
3224
3225TEST(DECONVOLUTION_OP_F32, grouped_1x1_varying_input_channels) {
3226 ASSERT_EQ(xnn_status_success, xnn_initialize());
3227 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
3228 DeconvolutionOperatorTester()
3229 .input_size(27, 29)
3230 .kernel_size(1, 1)
3231 .groups(2)
3232 .group_input_channels(input_channels)
3233 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3234 .iterations(1)
3235 .TestF32();
3236 }
3237}
3238
3239TEST(DECONVOLUTION_OP_F32, grouped_1x1_varying_output_channels) {
3240 ASSERT_EQ(xnn_status_success, xnn_initialize());
3241 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
3242 DeconvolutionOperatorTester()
3243 .input_size(27, 29)
3244 .kernel_size(1, 1)
3245 .groups(2)
3246 .group_input_channels(23)
3247 .group_output_channels(output_channels)
3248 .iterations(1)
3249 .TestF32();
3250 }
3251}
3252
3253TEST(DECONVOLUTION_OP_F32, grouped_1x1_with_input_stride) {
3254 ASSERT_EQ(xnn_status_success, xnn_initialize());
3255 DeconvolutionOperatorTester()
3256 .input_size(27, 29)
3257 .kernel_size(1, 1)
3258 .groups(2)
3259 .group_input_channels(23)
3260 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3261 .input_pixel_stride(47)
3262 .iterations(3)
3263 .TestF32();
3264}
3265
3266TEST(DECONVOLUTION_OP_F32, grouped_1x1_with_output_stride) {
3267 ASSERT_EQ(xnn_status_success, xnn_initialize());
3268 DeconvolutionOperatorTester()
3269 .input_size(27, 29)
3270 .kernel_size(1, 1)
3271 .groups(2)
3272 .group_input_channels(23)
3273 .group_output_channels(xnn_params.f32.gemm.nr + 3)
3274 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
3275 .iterations(3)
3276 .TestF32();
3277}
3278
3279TEST(DECONVOLUTION_OP_F32, grouped_1x1_with_qmin) {
3280 ASSERT_EQ(xnn_status_success, xnn_initialize());
3281 DeconvolutionOperatorTester()
3282 .input_size(27, 29)
3283 .kernel_size(1, 1)
3284 .groups(2)
3285 .group_input_channels(23)
3286 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3287 .qmin(128)
3288 .iterations(3)
3289 .TestF32();
3290}
3291
3292TEST(DECONVOLUTION_OP_F32, grouped_1x1_with_qmax) {
3293 ASSERT_EQ(xnn_status_success, xnn_initialize());
3294 DeconvolutionOperatorTester()
3295 .input_size(27, 29)
3296 .kernel_size(1, 1)
3297 .groups(2)
3298 .group_input_channels(23)
3299 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3300 .qmin(128)
3301 .iterations(3)
3302 .TestF32();
3303}
3304
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]3305TEST(DECONVOLUTION_OP_F32, grouped_1x1_without_bias) {
3306 ASSERT_EQ(xnn_status_success, xnn_initialize());
3307 DeconvolutionOperatorTester()
3308 .has_bias(false)
3309 .input_size(27, 29)
3310 .kernel_size(1, 1)
3311 .groups(2)
3312 .group_input_channels(23)
3313 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3314 .iterations(3)
3315 .TestF32();
3316}
3317
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3318/**************************** Future GEMM path, batched ****************************/
3319
3320TEST(DECONVOLUTION_OP_F32, batched_1x1) {
3321 ASSERT_EQ(xnn_status_success, xnn_initialize());
3322 DeconvolutionOperatorTester()
3323 .batch_size(2)
3324 .input_size(27, 29)
3325 .kernel_size(1, 1)
3326 .group_input_channels(23)
3327 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3328 .iterations(3)
3329 .TestF32();
3330}
3331
3332TEST(DECONVOLUTION_OP_F32, batched_1x1_varying_input_width) {
3333 ASSERT_EQ(xnn_status_success, xnn_initialize());
3334 for (size_t input_width = 25; input_width <= 31; input_width++) {
3335 DeconvolutionOperatorTester()
3336 .batch_size(2)
3337 .input_size(input_width, 29)
3338 .kernel_size(1, 1)
3339 .group_input_channels(23)
3340 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3341 .iterations(1)
3342 .TestF32();
3343 }
3344}
3345
3346TEST(DECONVOLUTION_OP_F32, batched_1x1_varying_input_height) {
3347 ASSERT_EQ(xnn_status_success, xnn_initialize());
3348 for (size_t input_height = 27; input_height <= 33; input_height++) {
3349 DeconvolutionOperatorTester()
3350 .batch_size(2)
3351 .input_size(27, input_height)
3352 .kernel_size(1, 1)
3353 .group_input_channels(23)
3354 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3355 .iterations(1)
3356 .TestF32();
3357 }
3358}
3359
3360TEST(DECONVOLUTION_OP_F32, batched_1x1_varying_input_channels) {
3361 ASSERT_EQ(xnn_status_success, xnn_initialize());
3362 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
3363 DeconvolutionOperatorTester()
3364 .batch_size(2)
3365 .input_size(27, 29)
3366 .kernel_size(1, 1)
3367 .group_input_channels(input_channels)
3368 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3369 .iterations(1)
3370 .TestF32();
3371 }
3372}
3373
3374TEST(DECONVOLUTION_OP_F32, batched_1x1_varying_output_channels) {
3375 ASSERT_EQ(xnn_status_success, xnn_initialize());
3376 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
3377 DeconvolutionOperatorTester()
3378 .batch_size(2)
3379 .input_size(27, 29)
3380 .kernel_size(1, 1)
3381 .group_input_channels(23)
3382 .group_output_channels(output_channels)
3383 .iterations(1)
3384 .TestF32();
3385 }
3386}
3387
3388TEST(DECONVOLUTION_OP_F32, batched_1x1_with_input_stride) {
3389 ASSERT_EQ(xnn_status_success, xnn_initialize());
3390 DeconvolutionOperatorTester()
3391 .batch_size(2)
3392 .input_size(27, 29)
3393 .kernel_size(1, 1)
3394 .group_input_channels(23)
3395 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3396 .input_pixel_stride(28)
3397 .iterations(3)
3398 .TestF32();
3399}
3400
3401TEST(DECONVOLUTION_OP_F32, batched_1x1_with_output_stride) {
3402 ASSERT_EQ(xnn_status_success, xnn_initialize());
3403 DeconvolutionOperatorTester()
3404 .batch_size(2)
3405 .input_size(27, 29)
3406 .kernel_size(1, 1)
3407 .group_input_channels(23)
3408 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3409 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
3410 .iterations(3)
3411 .TestF32();
3412}
3413
3414TEST(DECONVOLUTION_OP_F32, batched_1x1_with_qmin) {
3415 ASSERT_EQ(xnn_status_success, xnn_initialize());
3416 DeconvolutionOperatorTester()
3417 .batch_size(2)
3418 .input_size(27, 29)
3419 .kernel_size(1, 1)
3420 .group_input_channels(23)
3421 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3422 .qmin(128)
3423 .iterations(3)
3424 .TestF32();
3425}
3426
3427TEST(DECONVOLUTION_OP_F32, batched_1x1_with_qmax) {
3428 ASSERT_EQ(xnn_status_success, xnn_initialize());
3429 DeconvolutionOperatorTester()
3430 .batch_size(2)
3431 .input_size(27, 29)
3432 .kernel_size(1, 1)
3433 .group_input_channels(23)
3434 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3435 .qmin(128)
3436 .iterations(3)
3437 .TestF32();
3438}
3439
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]3440TEST(DECONVOLUTION_OP_F32, batched_1x1_without_bias) {
3441 ASSERT_EQ(xnn_status_success, xnn_initialize());
3442 DeconvolutionOperatorTester()
3443 .has_bias(false)
3444 .batch_size(2)
3445 .input_size(27, 29)
3446 .kernel_size(1, 1)
3447 .group_input_channels(23)
3448 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3449 .iterations(3)
3450 .TestF32();
3451}
3452
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3453/**************************** Future GEMM path, batched, grouped ****************************/
3454
3455TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1) {
3456 ASSERT_EQ(xnn_status_success, xnn_initialize());
3457 DeconvolutionOperatorTester()
3458 .batch_size(2)
3459 .input_size(27, 29)
3460 .kernel_size(1, 1)
3461 .groups(2)
3462 .group_input_channels(23)
3463 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3464 .iterations(3)
3465 .TestF32();
3466}
3467
3468TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_varying_input_width) {
3469 ASSERT_EQ(xnn_status_success, xnn_initialize());
3470 for (size_t input_width = 25; input_width <= 31; input_width++) {
3471 DeconvolutionOperatorTester()
3472 .batch_size(2)
3473 .input_size(input_width, 29)
3474 .kernel_size(1, 1)
3475 .groups(2)
3476 .group_input_channels(23)
3477 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3478 .iterations(1)
3479 .TestF32();
3480 }
3481}
3482
3483TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_varying_input_height) {
3484 ASSERT_EQ(xnn_status_success, xnn_initialize());
3485 for (size_t input_height = 27; input_height <= 33; input_height++) {
3486 DeconvolutionOperatorTester()
3487 .batch_size(2)
3488 .input_size(27, input_height)
3489 .kernel_size(1, 1)
3490 .groups(2)
3491 .group_input_channels(23)
3492 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3493 .iterations(1)
3494 .TestF32();
3495 }
3496}
3497
3498TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_varying_input_channels) {
3499 ASSERT_EQ(xnn_status_success, xnn_initialize());
3500 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
3501 DeconvolutionOperatorTester()
3502 .batch_size(2)
3503 .input_size(27, 29)
3504 .kernel_size(1, 1)
3505 .groups(2)
3506 .group_input_channels(input_channels)
3507 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3508 .iterations(1)
3509 .TestF32();
3510 }
3511}
3512
3513TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_varying_output_channels) {
3514 ASSERT_EQ(xnn_status_success, xnn_initialize());
3515 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
3516 DeconvolutionOperatorTester()
3517 .batch_size(2)
3518 .input_size(27, 29)
3519 .kernel_size(1, 1)
3520 .groups(2)
3521 .group_input_channels(23)
3522 .group_output_channels(output_channels)
3523 .iterations(1)
3524 .TestF32();
3525 }
3526}
3527
3528TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_with_input_stride) {
3529 ASSERT_EQ(xnn_status_success, xnn_initialize());
3530 DeconvolutionOperatorTester()
3531 .batch_size(2)
3532 .input_size(27, 29)
3533 .kernel_size(1, 1)
3534 .groups(2)
3535 .group_input_channels(23)
3536 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3537 .input_pixel_stride(47)
3538 .iterations(3)
3539 .TestF32();
3540}
3541
3542TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_with_output_stride) {
3543 ASSERT_EQ(xnn_status_success, xnn_initialize());
3544 DeconvolutionOperatorTester()
3545 .batch_size(2)
3546 .input_size(27, 29)
3547 .kernel_size(1, 1)
3548 .groups(2)
3549 .group_input_channels(23)
3550 .group_output_channels(xnn_params.f32.gemm.nr + 3)
3551 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
3552 .iterations(3)
3553 .TestF32();
3554}
3555
3556TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_with_qmin) {
3557 ASSERT_EQ(xnn_status_success, xnn_initialize());
3558 DeconvolutionOperatorTester()
3559 .batch_size(2)
3560 .input_size(27, 29)
3561 .kernel_size(1, 1)
3562 .groups(2)
3563 .group_input_channels(23)
3564 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3565 .qmin(128)
3566 .iterations(3)
3567 .TestF32();
3568}
3569
3570TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_with_qmax) {
3571 ASSERT_EQ(xnn_status_success, xnn_initialize());
3572 DeconvolutionOperatorTester()
3573 .batch_size(2)
3574 .input_size(27, 29)
3575 .kernel_size(1, 1)
3576 .groups(2)
3577 .group_input_channels(23)
3578 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3579 .qmin(128)
3580 .iterations(3)
3581 .TestF32();
3582}
3583
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]3584TEST(DECONVOLUTION_OP_F32, batched_grouped_1x1_without_bias) {
3585 ASSERT_EQ(xnn_status_success, xnn_initialize());
3586 DeconvolutionOperatorTester()
3587 .has_bias(false)
3588 .batch_size(2)
3589 .input_size(27, 29)
3590 .kernel_size(1, 1)
3591 .groups(2)
3592 .group_input_channels(23)
3593 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3594 .iterations(3)
3595 .TestF32();
3596}
3597
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3598/**************************** CONV path ****************************/
3599
3600TEST(DECONVOLUTION_OP_F32, 3x3) {
3601 ASSERT_EQ(xnn_status_success, xnn_initialize());
3602 DeconvolutionOperatorTester()
3603 .input_size(13, 12)
3604 .padding(1)
3605 .kernel_size(3, 3)
3606 .group_input_channels(15)
3607 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3608 .iterations(3)
3609 .TestF32();
3610}
3611
3612TEST(DECONVOLUTION_OP_F32, Kx3) {
3613 ASSERT_EQ(xnn_status_success, xnn_initialize());
3614 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
3615 DeconvolutionOperatorTester()
3616 .input_size(13, 12)
3617 .padding_width(1)
3618 .kernel_size(kernel_height, 3)
3619 .group_input_channels(17)
3620 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3621 .iterations(3)
3622 .TestF32();
3623 }
3624}
3625
3626TEST(DECONVOLUTION_OP_F32, 3xK) {
3627 ASSERT_EQ(xnn_status_success, xnn_initialize());
3628 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
3629 DeconvolutionOperatorTester()
3630 .input_size(13, 12)
3631 .padding_height(1)
3632 .kernel_size(3, kernel_width)
3633 .group_input_channels(17)
3634 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3635 .iterations(3)
3636 .TestF32();
3637 }
3638}
3639
3640TEST(DECONVOLUTION_OP_F32, 3x3_varying_height_padding) {
3641 ASSERT_EQ(xnn_status_success, xnn_initialize());
3642 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
3643 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
3644 DeconvolutionOperatorTester()
3645 .input_size(13, 12)
3646 .padding_width(1)
3647 .padding_top(padding_top)
3648 .padding_bottom(padding_bottom)
3649 .kernel_size(3, 3)
3650 .group_input_channels(15)
3651 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3652 .iterations(1)
3653 .TestF32();
3654 }
3655 }
3656}
3657
3658TEST(DECONVOLUTION_OP_F32, 3x3_varying_width_padding) {
3659 ASSERT_EQ(xnn_status_success, xnn_initialize());
3660 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
3661 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
3662 DeconvolutionOperatorTester()
3663 .input_size(13, 12)
3664 .padding_height(1)
3665 .padding_left(padding_left)
3666 .padding_right(padding_right)
3667 .kernel_size(3, 3)
3668 .group_input_channels(15)
3669 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3670 .iterations(1)
3671 .TestF32();
3672 }
3673 }
3674}
3675
3676TEST(DECONVOLUTION_OP_F32, 3x3_varying_height_adjustment) {
3677 ASSERT_EQ(xnn_status_success, xnn_initialize());
3678 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
3679 DeconvolutionOperatorTester()
3680 .input_size(13, 12)
3681 .padding(1)
3682 .adjustment_height(adjustment_height)
3683 .kernel_size(3, 3)
3684 .group_input_channels(15)
3685 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3686 .iterations(1)
3687 .TestF32();
3688 }
3689}
3690
3691TEST(DECONVOLUTION_OP_F32, 3x3_varying_width_adjustment) {
3692 ASSERT_EQ(xnn_status_success, xnn_initialize());
3693 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
3694 DeconvolutionOperatorTester()
3695 .input_size(13, 12)
3696 .padding(1)
3697 .adjustment_width(adjustment_width)
3698 .kernel_size(3, 3)
3699 .group_input_channels(15)
3700 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3701 .iterations(1)
3702 .TestF32();
3703 }
3704}
3705
3706TEST(DECONVOLUTION_OP_F32, 3x3_varying_input_height) {
3707 ASSERT_EQ(xnn_status_success, xnn_initialize());
3708 for (size_t input_height = 10; input_height <= 15; input_height++) {
3709 DeconvolutionOperatorTester()
3710 .input_size(input_height, 12)
3711 .padding(1)
3712 .kernel_size(3, 3)
3713 .group_input_channels(15)
3714 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3715 .iterations(1)
3716 .TestF32();
3717 }
3718}
3719
3720TEST(DECONVOLUTION_OP_F32, 3x3_varying_input_width) {
3721 ASSERT_EQ(xnn_status_success, xnn_initialize());
3722 for (size_t input_width = 9; input_width <= 14; input_width++) {
3723 DeconvolutionOperatorTester()
3724 .input_size(13, input_width)
3725 .padding(1)
3726 .kernel_size(3, 3)
3727 .group_input_channels(15)
3728 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3729 .iterations(1)
3730 .TestF32();
3731 }
3732}
3733
3734TEST(DECONVOLUTION_OP_F32, 3x3_varying_input_channels) {
3735 ASSERT_EQ(xnn_status_success, xnn_initialize());
3736 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
3737 DeconvolutionOperatorTester()
3738 .input_size(13, 12)
3739 .padding(1)
3740 .kernel_size(3, 3)
3741 .group_input_channels(input_channels)
3742 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3743 .iterations(1)
3744 .TestF32();
3745 }
3746}
3747
3748TEST(DECONVOLUTION_OP_F32, 3x3_varying_output_channels) {
3749 ASSERT_EQ(xnn_status_success, xnn_initialize());
3750 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
3751 DeconvolutionOperatorTester()
3752 .input_size(13, 12)
3753 .padding(1)
3754 .kernel_size(3, 3)
3755 .group_input_channels(23)
3756 .group_output_channels(output_channels)
3757 .iterations(1)
3758 .TestF32();
3759 }
3760}
3761
3762TEST(DECONVOLUTION_OP_F32, 3x3_with_height_dilation) {
3763 ASSERT_EQ(xnn_status_success, xnn_initialize());
3764 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
3765 DeconvolutionOperatorTester()
3766 .input_size(13, 12)
3767 .padding(1)
3768 .kernel_size(3, 3)
3769 .dilation_height(dilation_height)
3770 .group_input_channels(23)
3771 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3772 .iterations(3)
3773 .TestF32();
3774 }
3775}
3776
3777TEST(DECONVOLUTION_OP_F32, 3x3_with_width_dilation) {
3778 ASSERT_EQ(xnn_status_success, xnn_initialize());
3779 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
3780 DeconvolutionOperatorTester()
3781 .input_size(13, 12)
3782 .padding(1)
3783 .kernel_size(3, 3)
3784 .dilation_width(dilation_width)
3785 .group_input_channels(23)
3786 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3787 .iterations(3)
3788 .TestF32();
3789 }
3790}
3791
3792TEST(DECONVOLUTION_OP_F32, 3x3_with_height_dilation_and_stride) {
3793 ASSERT_EQ(xnn_status_success, xnn_initialize());
3794 DeconvolutionOperatorTester()
3795 .input_size(10, 9)
3796 .padding(1)
3797 .kernel_size(3, 3)
3798 .dilation_height(3)
3799 .stride_height(2)
3800 .group_input_channels(23)
3801 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3802 .iterations(3)
3803 .TestF32();
3804}
3805
3806TEST(DECONVOLUTION_OP_F32, 3x3_with_width_dilation_and_stride) {
3807 ASSERT_EQ(xnn_status_success, xnn_initialize());
3808 DeconvolutionOperatorTester()
3809 .input_size(10, 9)
3810 .padding(1)
3811 .kernel_size(3, 3)
3812 .dilation_width(3)
3813 .stride_width(2)
3814 .group_input_channels(23)
3815 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3816 .iterations(3)
3817 .TestF32();
3818}
3819
3820TEST(DECONVOLUTION_OP_F32, 3x3_with_input_stride) {
3821 ASSERT_EQ(xnn_status_success, xnn_initialize());
3822 DeconvolutionOperatorTester()
3823 .input_size(13, 12)
3824 .padding(1)
3825 .kernel_size(3, 3)
3826 .group_input_channels(23)
3827 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3828 .input_pixel_stride(28)
3829 .iterations(3)
3830 .TestF32();
3831}
3832
3833TEST(DECONVOLUTION_OP_F32, 3x3_with_output_stride) {
3834 ASSERT_EQ(xnn_status_success, xnn_initialize());
3835 DeconvolutionOperatorTester()
3836 .input_size(13, 12)
3837 .padding(1)
3838 .kernel_size(3, 3)
3839 .group_input_channels(23)
3840 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3841 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
3842 .iterations(3)
3843 .TestF32();
3844}
3845
3846TEST(DECONVOLUTION_OP_F32, 3x3_with_qmin) {
3847 ASSERT_EQ(xnn_status_success, xnn_initialize());
3848 DeconvolutionOperatorTester()
3849 .input_size(13, 12)
3850 .padding(1)
3851 .kernel_size(3, 3)
3852 .group_input_channels(23)
3853 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3854 .qmin(128)
3855 .iterations(3)
3856 .TestF32();
3857}
3858
3859TEST(DECONVOLUTION_OP_F32, 3x3_with_qmax) {
3860 ASSERT_EQ(xnn_status_success, xnn_initialize());
3861 DeconvolutionOperatorTester()
3862 .input_size(13, 12)
3863 .padding(1)
3864 .kernel_size(3, 3)
3865 .group_input_channels(23)
3866 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3867 .qmin(128)
3868 .iterations(3)
3869 .TestF32();
3870}
3871
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]3872TEST(DECONVOLUTION_OP_F32, 3x3_without_bias) {
3873 ASSERT_EQ(xnn_status_success, xnn_initialize());
3874 DeconvolutionOperatorTester()
3875 .has_bias(false)
3876 .input_size(13, 12)
3877 .padding(1)
3878 .kernel_size(3, 3)
3879 .group_input_channels(23)
3880 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3881 .iterations(3)
3882 .TestF32();
3883}
3884
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]3885/**************************** CONV path, grouped ****************************/
3886
3887TEST(DECONVOLUTION_OP_F32, grouped_3x3) {
3888 ASSERT_EQ(xnn_status_success, xnn_initialize());
3889 DeconvolutionOperatorTester()
3890 .input_size(13, 12)
3891 .padding(1)
3892 .kernel_size(3, 3)
3893 .groups(2)
3894 .group_input_channels(15)
3895 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3896 .iterations(3)
3897 .TestF32();
3898}
3899
3900TEST(DECONVOLUTION_OP_F32, grouped_Kx3) {
3901 ASSERT_EQ(xnn_status_success, xnn_initialize());
3902 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
3903 DeconvolutionOperatorTester()
3904 .input_size(13, 12)
3905 .padding_width(1)
3906 .kernel_size(kernel_height, 3)
3907 .groups(2)
3908 .group_input_channels(17)
3909 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3910 .iterations(3)
3911 .TestF32();
3912 }
3913}
3914
3915TEST(DECONVOLUTION_OP_F32, grouped_3xK) {
3916 ASSERT_EQ(xnn_status_success, xnn_initialize());
3917 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
3918 DeconvolutionOperatorTester()
3919 .input_size(13, 12)
3920 .padding_height(1)
3921 .kernel_size(3, kernel_width)
3922 .groups(2)
3923 .group_input_channels(17)
3924 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3925 .iterations(3)
3926 .TestF32();
3927 }
3928}
3929
3930TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_height_padding) {
3931 ASSERT_EQ(xnn_status_success, xnn_initialize());
3932 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
3933 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
3934 DeconvolutionOperatorTester()
3935 .input_size(13, 12)
3936 .padding_width(1)
3937 .padding_top(padding_top)
3938 .padding_bottom(padding_bottom)
3939 .kernel_size(3, 3)
3940 .groups(2)
3941 .group_input_channels(15)
3942 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3943 .iterations(1)
3944 .TestF32();
3945 }
3946 }
3947}
3948
3949TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_width_padding) {
3950 ASSERT_EQ(xnn_status_success, xnn_initialize());
3951 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
3952 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
3953 DeconvolutionOperatorTester()
3954 .input_size(13, 12)
3955 .padding_height(1)
3956 .padding_left(padding_left)
3957 .padding_right(padding_right)
3958 .kernel_size(3, 3)
3959 .groups(2)
3960 .group_input_channels(15)
3961 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3962 .iterations(1)
3963 .TestF32();
3964 }
3965 }
3966}
3967
3968TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_height_adjustment) {
3969 ASSERT_EQ(xnn_status_success, xnn_initialize());
3970 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
3971 DeconvolutionOperatorTester()
3972 .input_size(13, 12)
3973 .padding(1)
3974 .adjustment_height(adjustment_height)
3975 .kernel_size(3, 3)
3976 .groups(2)
3977 .group_input_channels(15)
3978 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3979 .iterations(1)
3980 .TestF32();
3981 }
3982}
3983
3984TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_width_adjustment) {
3985 ASSERT_EQ(xnn_status_success, xnn_initialize());
3986 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
3987 DeconvolutionOperatorTester()
3988 .input_size(13, 12)
3989 .padding(1)
3990 .adjustment_width(adjustment_width)
3991 .kernel_size(3, 3)
3992 .groups(2)
3993 .group_input_channels(15)
3994 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
3995 .iterations(1)
3996 .TestF32();
3997 }
3998}
3999
4000TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_input_height) {
4001 ASSERT_EQ(xnn_status_success, xnn_initialize());
4002 for (size_t input_height = 10; input_height <= 15; input_height++) {
4003 DeconvolutionOperatorTester()
4004 .input_size(input_height, 12)
4005 .padding(1)
4006 .kernel_size(3, 3)
4007 .groups(2)
4008 .group_input_channels(15)
4009 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4010 .iterations(1)
4011 .TestF32();
4012 }
4013}
4014
4015TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_input_width) {
4016 ASSERT_EQ(xnn_status_success, xnn_initialize());
4017 for (size_t input_width = 9; input_width <= 14; input_width++) {
4018 DeconvolutionOperatorTester()
4019 .input_size(13, input_width)
4020 .padding(1)
4021 .kernel_size(3, 3)
4022 .groups(2)
4023 .group_input_channels(15)
4024 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4025 .iterations(1)
4026 .TestF32();
4027 }
4028}
4029
4030TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_input_channels) {
4031 ASSERT_EQ(xnn_status_success, xnn_initialize());
4032 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
4033 DeconvolutionOperatorTester()
4034 .input_size(13, 12)
4035 .padding(1)
4036 .kernel_size(3, 3)
4037 .groups(2)
4038 .group_input_channels(input_channels)
4039 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4040 .iterations(1)
4041 .TestF32();
4042 }
4043}
4044
4045TEST(DECONVOLUTION_OP_F32, grouped_3x3_varying_output_channels) {
4046 ASSERT_EQ(xnn_status_success, xnn_initialize());
4047 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
4048 DeconvolutionOperatorTester()
4049 .input_size(13, 12)
4050 .padding(1)
4051 .kernel_size(3, 3)
4052 .groups(2)
4053 .group_input_channels(23)
4054 .group_output_channels(output_channels)
4055 .iterations(1)
4056 .TestF32();
4057 }
4058}
4059
4060TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_height_dilation) {
4061 ASSERT_EQ(xnn_status_success, xnn_initialize());
4062 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
4063 DeconvolutionOperatorTester()
4064 .input_size(13, 12)
4065 .padding(1)
4066 .kernel_size(3, 3)
4067 .dilation_height(dilation_height)
4068 .groups(2)
4069 .group_input_channels(23)
4070 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4071 .iterations(3)
4072 .TestF32();
4073 }
4074}
4075
4076TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_width_dilation) {
4077 ASSERT_EQ(xnn_status_success, xnn_initialize());
4078 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
4079 DeconvolutionOperatorTester()
4080 .input_size(13, 12)
4081 .padding(1)
4082 .kernel_size(3, 3)
4083 .dilation_width(dilation_width)
4084 .groups(2)
4085 .group_input_channels(23)
4086 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4087 .iterations(3)
4088 .TestF32();
4089 }
4090}
4091
4092TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_height_dilation_and_stride) {
4093 ASSERT_EQ(xnn_status_success, xnn_initialize());
4094 DeconvolutionOperatorTester()
4095 .input_size(10, 9)
4096 .padding(1)
4097 .kernel_size(3, 3)
4098 .dilation_height(3)
4099 .stride_height(2)
4100 .groups(2)
4101 .group_input_channels(23)
4102 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4103 .iterations(3)
4104 .TestF32();
4105}
4106
4107TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_width_dilation_and_stride) {
4108 ASSERT_EQ(xnn_status_success, xnn_initialize());
4109 DeconvolutionOperatorTester()
4110 .input_size(10, 9)
4111 .padding(1)
4112 .kernel_size(3, 3)
4113 .dilation_width(3)
4114 .stride_width(2)
4115 .groups(2)
4116 .group_input_channels(23)
4117 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4118 .iterations(3)
4119 .TestF32();
4120}
4121
4122TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_input_stride) {
4123 ASSERT_EQ(xnn_status_success, xnn_initialize());
4124 DeconvolutionOperatorTester()
4125 .input_size(13, 12)
4126 .padding(1)
4127 .kernel_size(3, 3)
4128 .groups(2)
4129 .group_input_channels(23)
4130 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4131 .input_pixel_stride(47)
4132 .iterations(3)
4133 .TestF32();
4134}
4135
4136TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_output_stride) {
4137 ASSERT_EQ(xnn_status_success, xnn_initialize());
4138 DeconvolutionOperatorTester()
4139 .input_size(13, 12)
4140 .padding(1)
4141 .kernel_size(3, 3)
4142 .groups(2)
4143 .group_input_channels(23)
4144 .group_output_channels(xnn_params.f32.gemm.nr + 3)
4145 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
4146 .iterations(3)
4147 .TestF32();
4148}
4149
4150TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_qmin) {
4151 ASSERT_EQ(xnn_status_success, xnn_initialize());
4152 DeconvolutionOperatorTester()
4153 .input_size(13, 12)
4154 .padding(1)
4155 .kernel_size(3, 3)
4156 .groups(2)
4157 .group_input_channels(23)
4158 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4159 .qmin(128)
4160 .iterations(3)
4161 .TestF32();
4162}
4163
4164TEST(DECONVOLUTION_OP_F32, grouped_3x3_with_qmax) {
4165 ASSERT_EQ(xnn_status_success, xnn_initialize());
4166 DeconvolutionOperatorTester()
4167 .input_size(13, 12)
4168 .padding(1)
4169 .kernel_size(3, 3)
4170 .groups(2)
4171 .group_input_channels(23)
4172 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4173 .qmin(128)
4174 .iterations(3)
4175 .TestF32();
4176}
4177
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]4178TEST(DECONVOLUTION_OP_F32, grouped_3x3_without_bias) {
4179 ASSERT_EQ(xnn_status_success, xnn_initialize());
4180 DeconvolutionOperatorTester()
4181 .has_bias(false)
4182 .input_size(13, 12)
4183 .padding(1)
4184 .kernel_size(3, 3)
4185 .groups(2)
4186 .group_input_channels(23)
4187 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4188 .iterations(3)
4189 .TestF32();
4190}
4191
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4192/**************************** CONV path, batched ****************************/
4193
4194TEST(DECONVOLUTION_OP_F32, batched_3x3) {
4195 ASSERT_EQ(xnn_status_success, xnn_initialize());
4196 DeconvolutionOperatorTester()
4197 .batch_size(2)
4198 .input_size(13, 12)
4199 .padding(1)
4200 .kernel_size(3, 3)
4201 .group_input_channels(15)
4202 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4203 .iterations(3)
4204 .TestF32();
4205}
4206
4207TEST(DECONVOLUTION_OP_F32, batched_Kx3) {
4208 ASSERT_EQ(xnn_status_success, xnn_initialize());
4209 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
4210 DeconvolutionOperatorTester()
4211 .batch_size(2)
4212 .input_size(13, 12)
4213 .padding_width(1)
4214 .kernel_size(kernel_height, 3)
4215 .group_input_channels(17)
4216 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4217 .iterations(3)
4218 .TestF32();
4219 }
4220}
4221
4222TEST(DECONVOLUTION_OP_F32, batched_3xK) {
4223 ASSERT_EQ(xnn_status_success, xnn_initialize());
4224 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
4225 DeconvolutionOperatorTester()
4226 .batch_size(2)
4227 .input_size(13, 12)
4228 .padding_height(1)
4229 .kernel_size(3, kernel_width)
4230 .group_input_channels(17)
4231 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4232 .iterations(3)
4233 .TestF32();
4234 }
4235}
4236
4237TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_height_padding) {
4238 ASSERT_EQ(xnn_status_success, xnn_initialize());
4239 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
4240 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
4241 DeconvolutionOperatorTester()
4242 .batch_size(2)
4243 .input_size(13, 12)
4244 .padding_width(1)
4245 .padding_top(padding_top)
4246 .padding_bottom(padding_bottom)
4247 .kernel_size(3, 3)
4248 .group_input_channels(15)
4249 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4250 .iterations(1)
4251 .TestF32();
4252 }
4253 }
4254}
4255
4256TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_width_padding) {
4257 ASSERT_EQ(xnn_status_success, xnn_initialize());
4258 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
4259 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
4260 DeconvolutionOperatorTester()
4261 .batch_size(2)
4262 .input_size(13, 12)
4263 .padding_height(1)
4264 .padding_left(padding_left)
4265 .padding_right(padding_right)
4266 .kernel_size(3, 3)
4267 .group_input_channels(15)
4268 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4269 .iterations(1)
4270 .TestF32();
4271 }
4272 }
4273}
4274
4275TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_height_adjustment) {
4276 ASSERT_EQ(xnn_status_success, xnn_initialize());
4277 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
4278 DeconvolutionOperatorTester()
4279 .batch_size(2)
4280 .input_size(13, 12)
4281 .padding(1)
4282 .adjustment_height(adjustment_height)
4283 .kernel_size(3, 3)
4284 .group_input_channels(15)
4285 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4286 .iterations(1)
4287 .TestF32();
4288 }
4289}
4290
4291TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_width_adjustment) {
4292 ASSERT_EQ(xnn_status_success, xnn_initialize());
4293 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
4294 DeconvolutionOperatorTester()
4295 .batch_size(2)
4296 .input_size(13, 12)
4297 .padding(1)
4298 .adjustment_width(adjustment_width)
4299 .kernel_size(3, 3)
4300 .group_input_channels(15)
4301 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4302 .iterations(1)
4303 .TestF32();
4304 }
4305}
4306
4307TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_input_height) {
4308 ASSERT_EQ(xnn_status_success, xnn_initialize());
4309 for (size_t input_height = 10; input_height <= 15; input_height++) {
4310 DeconvolutionOperatorTester()
4311 .batch_size(2)
4312 .input_size(input_height, 12)
4313 .padding(1)
4314 .kernel_size(3, 3)
4315 .group_input_channels(15)
4316 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4317 .iterations(1)
4318 .TestF32();
4319 }
4320}
4321
4322TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_input_width) {
4323 ASSERT_EQ(xnn_status_success, xnn_initialize());
4324 for (size_t input_width = 9; input_width <= 14; input_width++) {
4325 DeconvolutionOperatorTester()
4326 .batch_size(2)
4327 .input_size(13, input_width)
4328 .padding(1)
4329 .kernel_size(3, 3)
4330 .group_input_channels(15)
4331 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4332 .iterations(1)
4333 .TestF32();
4334 }
4335}
4336
4337TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_input_channels) {
4338 ASSERT_EQ(xnn_status_success, xnn_initialize());
4339 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
4340 DeconvolutionOperatorTester()
4341 .batch_size(2)
4342 .input_size(13, 12)
4343 .padding(1)
4344 .kernel_size(3, 3)
4345 .group_input_channels(input_channels)
4346 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4347 .iterations(1)
4348 .TestF32();
4349 }
4350}
4351
4352TEST(DECONVOLUTION_OP_F32, batched_3x3_varying_output_channels) {
4353 ASSERT_EQ(xnn_status_success, xnn_initialize());
4354 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
4355 DeconvolutionOperatorTester()
4356 .batch_size(2)
4357 .input_size(13, 12)
4358 .padding(1)
4359 .kernel_size(3, 3)
4360 .group_input_channels(23)
4361 .group_output_channels(output_channels)
4362 .iterations(1)
4363 .TestF32();
4364 }
4365}
4366
4367TEST(DECONVOLUTION_OP_F32, batched_3x3_with_height_dilation) {
4368 ASSERT_EQ(xnn_status_success, xnn_initialize());
4369 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
4370 DeconvolutionOperatorTester()
4371 .batch_size(2)
4372 .input_size(13, 12)
4373 .padding(1)
4374 .kernel_size(3, 3)
4375 .dilation_height(dilation_height)
4376 .group_input_channels(23)
4377 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4378 .iterations(3)
4379 .TestF32();
4380 }
4381}
4382
4383TEST(DECONVOLUTION_OP_F32, batched_3x3_with_width_dilation) {
4384 ASSERT_EQ(xnn_status_success, xnn_initialize());
4385 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
4386 DeconvolutionOperatorTester()
4387 .batch_size(2)
4388 .input_size(13, 12)
4389 .padding(1)
4390 .kernel_size(3, 3)
4391 .dilation_width(dilation_width)
4392 .group_input_channels(23)
4393 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4394 .iterations(3)
4395 .TestF32();
4396 }
4397}
4398
4399TEST(DECONVOLUTION_OP_F32, batched_3x3_with_height_dilation_and_stride) {
4400 ASSERT_EQ(xnn_status_success, xnn_initialize());
4401 DeconvolutionOperatorTester()
4402 .batch_size(2)
4403 .input_size(10, 9)
4404 .padding(1)
4405 .kernel_size(3, 3)
4406 .dilation_height(3)
4407 .stride_height(2)
4408 .group_input_channels(23)
4409 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4410 .iterations(3)
4411 .TestF32();
4412}
4413
4414TEST(DECONVOLUTION_OP_F32, batched_3x3_with_width_dilation_and_stride) {
4415 ASSERT_EQ(xnn_status_success, xnn_initialize());
4416 DeconvolutionOperatorTester()
4417 .batch_size(2)
4418 .input_size(10, 9)
4419 .padding(1)
4420 .kernel_size(3, 3)
4421 .dilation_width(3)
4422 .stride_width(2)
4423 .group_input_channels(23)
4424 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4425 .iterations(3)
4426 .TestF32();
4427}
4428
4429TEST(DECONVOLUTION_OP_F32, batched_3x3_with_input_stride) {
4430 ASSERT_EQ(xnn_status_success, xnn_initialize());
4431 DeconvolutionOperatorTester()
4432 .batch_size(2)
4433 .input_size(13, 12)
4434 .padding(1)
4435 .kernel_size(3, 3)
4436 .group_input_channels(23)
4437 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4438 .input_pixel_stride(28)
4439 .iterations(3)
4440 .TestF32();
4441}
4442
4443TEST(DECONVOLUTION_OP_F32, batched_3x3_with_output_stride) {
4444 ASSERT_EQ(xnn_status_success, xnn_initialize());
4445 DeconvolutionOperatorTester()
4446 .batch_size(2)
4447 .input_size(13, 12)
4448 .padding(1)
4449 .kernel_size(3, 3)
4450 .group_input_channels(23)
4451 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4452 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
4453 .iterations(3)
4454 .TestF32();
4455}
4456
4457TEST(DECONVOLUTION_OP_F32, batched_3x3_with_qmin) {
4458 ASSERT_EQ(xnn_status_success, xnn_initialize());
4459 DeconvolutionOperatorTester()
4460 .batch_size(2)
4461 .input_size(13, 12)
4462 .padding(1)
4463 .kernel_size(3, 3)
4464 .group_input_channels(23)
4465 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4466 .qmin(128)
4467 .iterations(3)
4468 .TestF32();
4469}
4470
4471TEST(DECONVOLUTION_OP_F32, batched_3x3_with_qmax) {
4472 ASSERT_EQ(xnn_status_success, xnn_initialize());
4473 DeconvolutionOperatorTester()
4474 .batch_size(2)
4475 .input_size(13, 12)
4476 .padding(1)
4477 .kernel_size(3, 3)
4478 .group_input_channels(23)
4479 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4480 .qmin(128)
4481 .iterations(3)
4482 .TestF32();
4483}
4484
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]4485TEST(DECONVOLUTION_OP_F32, batched_3x3_without_bias) {
4486 ASSERT_EQ(xnn_status_success, xnn_initialize());
4487 DeconvolutionOperatorTester()
4488 .has_bias(false)
4489 .batch_size(2)
4490 .input_size(13, 12)
4491 .padding(1)
4492 .kernel_size(3, 3)
4493 .group_input_channels(23)
4494 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4495 .iterations(3)
4496 .TestF32();
4497}
4498
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4499/**************************** CONV path, grouped, batched ****************************/
4500
4501TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3) {
4502 ASSERT_EQ(xnn_status_success, xnn_initialize());
4503 DeconvolutionOperatorTester()
4504 .batch_size(2)
4505 .input_size(13, 12)
4506 .padding(1)
4507 .kernel_size(3, 3)
4508 .groups(2)
4509 .group_input_channels(15)
4510 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4511 .iterations(3)
4512 .TestF32();
4513}
4514
4515TEST(DECONVOLUTION_OP_F32, batched_grouped_Kx3) {
4516 ASSERT_EQ(xnn_status_success, xnn_initialize());
4517 for (size_t kernel_height = 1; kernel_height <= 4; kernel_height *= 2) {
4518 DeconvolutionOperatorTester()
4519 .batch_size(2)
4520 .input_size(13, 12)
4521 .padding_width(1)
4522 .kernel_size(kernel_height, 3)
4523 .groups(2)
4524 .group_input_channels(17)
4525 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4526 .iterations(3)
4527 .TestF32();
4528 }
4529}
4530
4531TEST(DECONVOLUTION_OP_F32, batched_grouped_3xK) {
4532 ASSERT_EQ(xnn_status_success, xnn_initialize());
4533 for (size_t kernel_width = 1; kernel_width <= 4; kernel_width *= 2) {
4534 DeconvolutionOperatorTester()
4535 .batch_size(2)
4536 .input_size(13, 12)
4537 .padding_height(1)
4538 .kernel_size(3, kernel_width)
4539 .groups(2)
4540 .group_input_channels(17)
4541 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4542 .iterations(3)
4543 .TestF32();
4544 }
4545}
4546
4547TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_height_padding) {
4548 ASSERT_EQ(xnn_status_success, xnn_initialize());
4549 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
4550 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
4551 DeconvolutionOperatorTester()
4552 .batch_size(2)
4553 .input_size(13, 12)
4554 .padding_width(1)
4555 .padding_top(padding_top)
4556 .padding_bottom(padding_bottom)
4557 .kernel_size(3, 3)
4558 .groups(2)
4559 .group_input_channels(15)
4560 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4561 .iterations(1)
4562 .TestF32();
4563 }
4564 }
4565}
4566
4567TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_width_padding) {
4568 ASSERT_EQ(xnn_status_success, xnn_initialize());
4569 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
4570 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
4571 DeconvolutionOperatorTester()
4572 .batch_size(2)
4573 .input_size(13, 12)
4574 .padding_height(1)
4575 .padding_left(padding_left)
4576 .padding_right(padding_right)
4577 .kernel_size(3, 3)
4578 .groups(2)
4579 .group_input_channels(15)
4580 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4581 .iterations(1)
4582 .TestF32();
4583 }
4584 }
4585}
4586
4587TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_height_adjustment) {
4588 ASSERT_EQ(xnn_status_success, xnn_initialize());
4589 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
4590 DeconvolutionOperatorTester()
4591 .batch_size(2)
4592 .input_size(13, 12)
4593 .padding(1)
4594 .adjustment_height(adjustment_height)
4595 .kernel_size(3, 3)
4596 .groups(2)
4597 .group_input_channels(15)
4598 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4599 .iterations(1)
4600 .TestF32();
4601 }
4602}
4603
4604TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_width_adjustment) {
4605 ASSERT_EQ(xnn_status_success, xnn_initialize());
4606 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
4607 DeconvolutionOperatorTester()
4608 .batch_size(2)
4609 .input_size(13, 12)
4610 .padding(1)
4611 .adjustment_width(adjustment_width)
4612 .kernel_size(3, 3)
4613 .groups(2)
4614 .group_input_channels(15)
4615 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4616 .iterations(1)
4617 .TestF32();
4618 }
4619}
4620
4621TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_input_height) {
4622 ASSERT_EQ(xnn_status_success, xnn_initialize());
4623 for (size_t input_height = 10; input_height <= 15; input_height++) {
4624 DeconvolutionOperatorTester()
4625 .batch_size(2)
4626 .input_size(input_height, 12)
4627 .padding(1)
4628 .kernel_size(3, 3)
4629 .groups(2)
4630 .group_input_channels(15)
4631 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4632 .iterations(1)
4633 .TestF32();
4634 }
4635}
4636
4637TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_input_width) {
4638 ASSERT_EQ(xnn_status_success, xnn_initialize());
4639 for (size_t input_width = 9; input_width <= 14; input_width++) {
4640 DeconvolutionOperatorTester()
4641 .batch_size(2)
4642 .input_size(13, input_width)
4643 .padding(1)
4644 .kernel_size(3, 3)
4645 .groups(2)
4646 .group_input_channels(15)
4647 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4648 .iterations(1)
4649 .TestF32();
4650 }
4651}
4652
4653TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_input_channels) {
4654 ASSERT_EQ(xnn_status_success, xnn_initialize());
4655 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
4656 DeconvolutionOperatorTester()
4657 .batch_size(2)
4658 .input_size(13, 12)
4659 .padding(1)
4660 .kernel_size(3, 3)
4661 .groups(2)
4662 .group_input_channels(input_channels)
4663 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4664 .iterations(1)
4665 .TestF32();
4666 }
4667}
4668
4669TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_varying_output_channels) {
4670 ASSERT_EQ(xnn_status_success, xnn_initialize());
4671 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
4672 DeconvolutionOperatorTester()
4673 .batch_size(2)
4674 .input_size(13, 12)
4675 .padding(1)
4676 .kernel_size(3, 3)
4677 .groups(2)
4678 .group_input_channels(23)
4679 .group_output_channels(output_channels)
4680 .iterations(1)
4681 .TestF32();
4682 }
4683}
4684
4685TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_height_dilation) {
4686 ASSERT_EQ(xnn_status_success, xnn_initialize());
4687 for (size_t dilation_height = 2; dilation_height <= 3; dilation_height++) {
4688 DeconvolutionOperatorTester()
4689 .batch_size(2)
4690 .input_size(13, 12)
4691 .padding(1)
4692 .kernel_size(3, 3)
4693 .dilation_height(dilation_height)
4694 .groups(2)
4695 .group_input_channels(23)
4696 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4697 .iterations(3)
4698 .TestF32();
4699 }
4700}
4701
4702TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_width_dilation) {
4703 ASSERT_EQ(xnn_status_success, xnn_initialize());
4704 for (size_t dilation_width = 2; dilation_width <= 3; dilation_width++) {
4705 DeconvolutionOperatorTester()
4706 .batch_size(2)
4707 .input_size(13, 12)
4708 .padding(1)
4709 .kernel_size(3, 3)
4710 .dilation_width(dilation_width)
4711 .groups(2)
4712 .group_input_channels(23)
4713 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4714 .iterations(3)
4715 .TestF32();
4716 }
4717}
4718
4719TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_height_dilation_and_stride) {
4720 ASSERT_EQ(xnn_status_success, xnn_initialize());
4721 DeconvolutionOperatorTester()
4722 .batch_size(2)
4723 .input_size(10, 9)
4724 .padding(1)
4725 .kernel_size(3, 3)
4726 .dilation_height(3)
4727 .stride_width(2)
4728 .groups(2)
4729 .group_input_channels(23)
4730 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4731 .iterations(3)
4732 .TestF32();
4733}
4734
4735TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_width_dilation_and_stride) {
4736 ASSERT_EQ(xnn_status_success, xnn_initialize());
4737 DeconvolutionOperatorTester()
4738 .batch_size(2)
4739 .input_size(10, 9)
4740 .padding(1)
4741 .kernel_size(3, 3)
4742 .dilation_width(3)
4743 .stride_width(2)
4744 .groups(2)
4745 .group_input_channels(23)
4746 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4747 .iterations(3)
4748 .TestF32();
4749}
4750
4751TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_input_stride) {
4752 ASSERT_EQ(xnn_status_success, xnn_initialize());
4753 DeconvolutionOperatorTester()
4754 .batch_size(2)
4755 .input_size(13, 12)
4756 .padding(1)
4757 .kernel_size(3, 3)
4758 .groups(2)
4759 .group_input_channels(23)
4760 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4761 .input_pixel_stride(47)
4762 .iterations(3)
4763 .TestF32();
4764}
4765
4766TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_output_stride) {
4767 ASSERT_EQ(xnn_status_success, xnn_initialize());
4768 DeconvolutionOperatorTester()
4769 .batch_size(2)
4770 .input_size(13, 12)
4771 .padding(1)
4772 .kernel_size(3, 3)
4773 .groups(2)
4774 .group_input_channels(23)
4775 .group_output_channels(xnn_params.f32.gemm.nr + 3)
4776 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
4777 .iterations(3)
4778 .TestF32();
4779}
4780
4781TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_qmin) {
4782 ASSERT_EQ(xnn_status_success, xnn_initialize());
4783 DeconvolutionOperatorTester()
4784 .batch_size(2)
4785 .input_size(13, 12)
4786 .padding(1)
4787 .kernel_size(3, 3)
4788 .groups(2)
4789 .group_input_channels(23)
4790 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4791 .qmin(128)
4792 .iterations(3)
4793 .TestF32();
4794}
4795
4796TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_with_qmax) {
4797 ASSERT_EQ(xnn_status_success, xnn_initialize());
4798 DeconvolutionOperatorTester()
4799 .batch_size(2)
4800 .input_size(13, 12)
4801 .padding(1)
4802 .kernel_size(3, 3)
4803 .groups(2)
4804 .group_input_channels(23)
4805 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4806 .qmin(128)
4807 .iterations(3)
4808 .TestF32();
4809}
4810
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]4811TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3_without_bias) {
4812 ASSERT_EQ(xnn_status_success, xnn_initialize());
4813 DeconvolutionOperatorTester()
4814 .has_bias(false)
4815 .batch_size(2)
4816 .input_size(13, 12)
4817 .padding(1)
4818 .kernel_size(3, 3)
4819 .groups(2)
4820 .group_input_channels(23)
4821 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4822 .iterations(3)
4823 .TestF32();
4824}
4825
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4826/**************************** CONV path, setup ****************************/
4827
4828TEST(DECONVOLUTION_OP_F32, 3x3_setup_changing_batch) {
4829 ASSERT_EQ(xnn_status_success, xnn_initialize());
4830 DeconvolutionOperatorTester()
4831 .batch_size(2)
4832 .next_batch_size(5)
4833 .input_height(12)
4834 .input_width(13)
4835 .kernel_height(3)
4836 .kernel_width(5)
4837 .groups(2)
4838 .group_input_channels(15)
4839 .group_output_channels(17)
4840 .TestSetupF32();
4841}
4842
4843TEST(DECONVOLUTION_OP_F32, 3x3_setup_changing_height) {
4844 ASSERT_EQ(xnn_status_success, xnn_initialize());
4845 DeconvolutionOperatorTester()
4846 .batch_size(2)
4847 .input_height(12)
4848 .input_width(13)
4849 .next_input_height(14)
4850 .kernel_height(3)
4851 .kernel_width(5)
4852 .groups(2)
4853 .group_input_channels(15)
4854 .group_output_channels(17)
4855 .TestSetupF32();
4856}
4857
4858TEST(DECONVOLUTION_OP_F32, 3x3_setup_changing_width) {
4859 ASSERT_EQ(xnn_status_success, xnn_initialize());
4860 DeconvolutionOperatorTester()
4861 .batch_size(2)
4862 .input_height(12)
4863 .input_width(13)
4864 .next_input_width(14)
4865 .kernel_height(3)
4866 .kernel_width(5)
4867 .groups(2)
4868 .group_input_channels(15)
4869 .group_output_channels(17)
4870 .TestSetupF32();
4871}
4872
4873/**************************** SUBCONV2D path ****************************/
4874
4875TEST(DECONVOLUTION_OP_F32, 3x3s2) {
4876 ASSERT_EQ(xnn_status_success, xnn_initialize());
4877 DeconvolutionOperatorTester()
4878 .input_size(10, 9)
4879 .padding(1)
4880 .kernel_size(3, 3)
4881 .stride(2)
4882 .group_input_channels(15)
4883 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4884 .iterations(3)
4885 .TestF32();
4886}
4887
4888TEST(DECONVOLUTION_OP_F32, Kx3s2) {
4889 ASSERT_EQ(xnn_status_success, xnn_initialize());
4890 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
4891 DeconvolutionOperatorTester()
4892 .input_size(10, 9)
4893 .padding_width(1)
4894 .kernel_size(kernel_height, 3)
4895 .stride(2)
4896 .group_input_channels(17)
4897 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4898 .iterations(3)
4899 .TestF32();
4900 }
4901}
4902
4903TEST(DECONVOLUTION_OP_F32, 3xKs2) {
4904 ASSERT_EQ(xnn_status_success, xnn_initialize());
4905 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
4906 DeconvolutionOperatorTester()
4907 .input_size(10, 9)
4908 .padding_height(1)
4909 .kernel_size(3, kernel_width)
4910 .stride(2)
4911 .group_input_channels(17)
4912 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4913 .iterations(3)
4914 .TestF32();
4915 }
4916}
4917
4918TEST(DECONVOLUTION_OP_F32, 3x3sSx1) {
4919 ASSERT_EQ(xnn_status_success, xnn_initialize());
4920 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
4921 DeconvolutionOperatorTester()
4922 .input_size(10, 9)
4923 .padding(1)
4924 .padding_width(1)
4925 .kernel_size(3, 3)
4926 .stride_height(stride_height)
4927 .group_input_channels(17)
4928 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4929 .iterations(3)
4930 .TestF32();
4931 }
4932}
4933
4934TEST(DECONVOLUTION_OP_F32, 3x3s1xS) {
4935 ASSERT_EQ(xnn_status_success, xnn_initialize());
4936 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
4937 DeconvolutionOperatorTester()
4938 .input_size(10, 9)
4939 .padding(1)
4940 .padding_width(1)
4941 .kernel_size(3, 3)
4942 .stride_width(stride_width)
4943 .group_input_channels(17)
4944 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4945 .iterations(3)
4946 .TestF32();
4947 }
4948}
4949
4950TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_height_padding) {
4951 ASSERT_EQ(xnn_status_success, xnn_initialize());
4952 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
4953 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
4954 DeconvolutionOperatorTester()
4955 .input_size(10, 9)
4956 .padding_width(1)
4957 .padding_top(padding_top)
4958 .padding_bottom(padding_bottom)
4959 .kernel_size(3, 3)
4960 .stride(2)
4961 .group_input_channels(15)
4962 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4963 .iterations(1)
4964 .TestF32();
4965 }
4966 }
4967}
4968
4969TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_width_padding) {
4970 ASSERT_EQ(xnn_status_success, xnn_initialize());
4971 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
4972 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
4973 DeconvolutionOperatorTester()
4974 .input_size(10, 9)
4975 .padding_height(1)
4976 .padding_left(padding_left)
4977 .padding_right(padding_right)
4978 .kernel_size(3, 3)
4979 .stride(2)
4980 .group_input_channels(15)
4981 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4982 .iterations(1)
4983 .TestF32();
4984 }
4985 }
4986}
4987
4988TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_height_adjustment) {
4989 ASSERT_EQ(xnn_status_success, xnn_initialize());
4990 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
4991 DeconvolutionOperatorTester()
4992 .input_size(10, 9)
4993 .padding(1)
4994 .adjustment_height(adjustment_height)
4995 .kernel_size(3, 3)
4996 .stride(2)
4997 .group_input_channels(15)
4998 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
4999 .iterations(1)
5000 .TestF32();
5001 }
5002}
5003
5004TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_width_adjustment) {
5005 ASSERT_EQ(xnn_status_success, xnn_initialize());
5006 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
5007 DeconvolutionOperatorTester()
5008 .input_size(10, 9)
5009 .padding(1)
5010 .adjustment_width(adjustment_width)
5011 .kernel_size(3, 3)
5012 .stride(2)
5013 .group_input_channels(15)
5014 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5015 .iterations(1)
5016 .TestF32();
5017 }
5018}
5019
5020TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_input_height) {
5021 ASSERT_EQ(xnn_status_success, xnn_initialize());
5022 for (size_t input_height = 8; input_height <= 12; input_height++) {
5023 DeconvolutionOperatorTester()
5024 .input_size(input_height, 9)
5025 .padding(1)
5026 .kernel_size(3, 3)
5027 .stride(2)
5028 .group_input_channels(15)
5029 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5030 .iterations(1)
5031 .TestF32();
5032 }
5033}
5034
5035TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_input_width) {
5036 ASSERT_EQ(xnn_status_success, xnn_initialize());
5037 for (size_t input_width = 7; input_width <= 11; input_width++) {
5038 DeconvolutionOperatorTester()
5039 .input_size(10, input_width)
5040 .padding(1)
5041 .kernel_size(3, 3)
5042 .stride(2)
5043 .group_input_channels(15)
5044 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5045 .iterations(1)
5046 .TestF32();
5047 }
5048}
5049
5050TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_input_channels) {
5051 ASSERT_EQ(xnn_status_success, xnn_initialize());
5052 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
5053 DeconvolutionOperatorTester()
5054 .input_size(10, 9)
5055 .padding(1)
5056 .kernel_size(3, 3)
5057 .stride(2)
5058 .group_input_channels(input_channels)
5059 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5060 .iterations(1)
5061 .TestF32();
5062 }
5063}
5064
5065TEST(DECONVOLUTION_OP_F32, 3x3s2_varying_output_channels) {
5066 ASSERT_EQ(xnn_status_success, xnn_initialize());
5067 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
5068 DeconvolutionOperatorTester()
5069 .input_size(10, 9)
5070 .padding(1)
5071 .kernel_size(3, 3)
5072 .stride(2)
5073 .group_input_channels(23)
5074 .group_output_channels(output_channels)
5075 .iterations(1)
5076 .TestF32();
5077 }
5078}
5079
5080TEST(DECONVOLUTION_OP_F32, 3x3s2_with_input_stride) {
5081 ASSERT_EQ(xnn_status_success, xnn_initialize());
5082 DeconvolutionOperatorTester()
5083 .input_size(10, 9)
5084 .padding(1)
5085 .kernel_size(3, 3)
5086 .stride(2)
5087 .group_input_channels(23)
5088 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5089 .input_pixel_stride(28)
5090 .iterations(3)
5091 .TestF32();
5092}
5093
5094TEST(DECONVOLUTION_OP_F32, 3x3s2_with_output_stride) {
5095 ASSERT_EQ(xnn_status_success, xnn_initialize());
5096 DeconvolutionOperatorTester()
5097 .input_size(10, 9)
5098 .padding(1)
5099 .kernel_size(3, 3)
5100 .stride(2)
5101 .group_input_channels(23)
5102 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5103 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
5104 .iterations(3)
5105 .TestF32();
5106}
5107
5108TEST(DECONVOLUTION_OP_F32, 3x3s2_with_qmin) {
5109 ASSERT_EQ(xnn_status_success, xnn_initialize());
5110 DeconvolutionOperatorTester()
5111 .input_size(10, 9)
5112 .padding(1)
5113 .kernel_size(3, 3)
5114 .stride(2)
5115 .group_input_channels(23)
5116 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5117 .qmin(128)
5118 .iterations(3)
5119 .TestF32();
5120}
5121
5122TEST(DECONVOLUTION_OP_F32, 3x3s2_with_qmax) {
5123 ASSERT_EQ(xnn_status_success, xnn_initialize());
5124 DeconvolutionOperatorTester()
5125 .input_size(10, 9)
5126 .padding(1)
5127 .kernel_size(3, 3)
5128 .stride(2)
5129 .group_input_channels(23)
5130 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5131 .qmin(128)
5132 .iterations(3)
5133 .TestF32();
5134}
5135
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]5136TEST(DECONVOLUTION_OP_F32, 3x3s2_without_bias) {
5137 ASSERT_EQ(xnn_status_success, xnn_initialize());
5138 DeconvolutionOperatorTester()
5139 .has_bias(false)
5140 .input_size(10, 9)
5141 .padding(1)
5142 .kernel_size(3, 3)
5143 .stride(2)
5144 .group_input_channels(23)
5145 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5146 .iterations(3)
5147 .TestF32();
5148}
5149
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]5150/**************************** SUBCONV2D path, grouped ****************************/
5151
5152TEST(DECONVOLUTION_OP_F32, grouped_3x3s2) {
5153 ASSERT_EQ(xnn_status_success, xnn_initialize());
5154 DeconvolutionOperatorTester()
5155 .input_size(10, 9)
5156 .padding(1)
5157 .kernel_size(3, 3)
5158 .stride(2)
5159 .groups(2)
5160 .group_input_channels(17)
5161 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5162 .iterations(3)
5163 .TestF32();
5164}
5165
5166TEST(DECONVOLUTION_OP_F32, grouped_Kx3s2) {
5167 ASSERT_EQ(xnn_status_success, xnn_initialize());
5168 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
5169 DeconvolutionOperatorTester()
5170 .input_size(10, 9)
5171 .padding_width(1)
5172 .kernel_size(kernel_height, 3)
5173 .stride(2)
5174 .groups(2)
5175 .group_input_channels(17)
5176 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5177 .iterations(3)
5178 .TestF32();
5179 }
5180}
5181
5182TEST(DECONVOLUTION_OP_F32, grouped_3xKs2) {
5183 ASSERT_EQ(xnn_status_success, xnn_initialize());
5184 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
5185 DeconvolutionOperatorTester()
5186 .input_size(10, 9)
5187 .padding_height(1)
5188 .kernel_size(3, kernel_width)
5189 .stride(2)
5190 .groups(2)
5191 .group_input_channels(17)
5192 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5193 .iterations(3)
5194 .TestF32();
5195 }
5196}
5197
5198TEST(DECONVOLUTION_OP_F32, grouped_3x3sSx1) {
5199 ASSERT_EQ(xnn_status_success, xnn_initialize());
5200 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
5201 DeconvolutionOperatorTester()
5202 .input_size(10, 9)
5203 .padding(1)
5204 .padding_width(1)
5205 .kernel_size(3, 3)
5206 .stride_height(stride_height)
5207 .groups(2)
5208 .group_input_channels(17)
5209 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5210 .iterations(3)
5211 .TestF32();
5212 }
5213}
5214
5215TEST(DECONVOLUTION_OP_F32, grouped_3x3s1xS) {
5216 ASSERT_EQ(xnn_status_success, xnn_initialize());
5217 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
5218 DeconvolutionOperatorTester()
5219 .input_size(10, 9)
5220 .padding(1)
5221 .padding_width(1)
5222 .kernel_size(3, 3)
5223 .stride_width(stride_width)
5224 .groups(2)
5225 .group_input_channels(17)
5226 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5227 .iterations(3)
5228 .TestF32();
5229 }
5230}
5231
5232TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_height_padding) {
5233 ASSERT_EQ(xnn_status_success, xnn_initialize());
5234 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
5235 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
5236 DeconvolutionOperatorTester()
5237 .input_size(10, 9)
5238 .padding_width(1)
5239 .padding_top(padding_top)
5240 .padding_bottom(padding_bottom)
5241 .kernel_size(3, 3)
5242 .stride(2)
5243 .groups(2)
5244 .group_input_channels(17)
5245 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5246 .iterations(1)
5247 .TestF32();
5248 }
5249 }
5250}
5251
5252TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_width_padding) {
5253 ASSERT_EQ(xnn_status_success, xnn_initialize());
5254 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
5255 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
5256 DeconvolutionOperatorTester()
5257 .input_size(10, 9)
5258 .padding_height(1)
5259 .padding_left(padding_left)
5260 .padding_right(padding_right)
5261 .kernel_size(3, 3)
5262 .stride(2)
5263 .groups(2)
5264 .group_input_channels(17)
5265 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5266 .iterations(1)
5267 .TestF32();
5268 }
5269 }
5270}
5271
5272TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_height_adjustment) {
5273 ASSERT_EQ(xnn_status_success, xnn_initialize());
5274 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
5275 DeconvolutionOperatorTester()
5276 .input_size(10, 9)
5277 .padding(1)
5278 .adjustment_height(adjustment_height)
5279 .kernel_size(3, 3)
5280 .stride(2)
5281 .groups(2)
5282 .group_input_channels(17)
5283 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5284 .iterations(1)
5285 .TestF32();
5286 }
5287}
5288
5289TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_width_adjustment) {
5290 ASSERT_EQ(xnn_status_success, xnn_initialize());
5291 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
5292 DeconvolutionOperatorTester()
5293 .input_size(10, 9)
5294 .padding(1)
5295 .adjustment_width(adjustment_width)
5296 .kernel_size(3, 3)
5297 .stride(2)
5298 .groups(2)
5299 .group_input_channels(17)
5300 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5301 .iterations(1)
5302 .TestF32();
5303 }
5304}
5305
5306TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_input_height) {
5307 ASSERT_EQ(xnn_status_success, xnn_initialize());
5308 for (size_t input_height = 8; input_height <= 12; input_height++) {
5309 DeconvolutionOperatorTester()
5310 .input_size(input_height, 9)
5311 .padding(1)
5312 .kernel_size(3, 3)
5313 .stride(2)
5314 .groups(2)
5315 .group_input_channels(17)
5316 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5317 .iterations(1)
5318 .TestF32();
5319 }
5320}
5321
5322TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_input_width) {
5323 ASSERT_EQ(xnn_status_success, xnn_initialize());
5324 for (size_t input_width = 7; input_width <= 11; input_width++) {
5325 DeconvolutionOperatorTester()
5326 .input_size(10, input_width)
5327 .padding(1)
5328 .kernel_size(3, 3)
5329 .stride(2)
5330 .groups(2)
5331 .group_input_channels(17)
5332 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5333 .iterations(1)
5334 .TestF32();
5335 }
5336}
5337
5338TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_input_channels) {
5339 ASSERT_EQ(xnn_status_success, xnn_initialize());
5340 for (size_t input_channels = 14; input_channels <= 20; input_channels++) {
5341 DeconvolutionOperatorTester()
5342 .input_size(10, 9)
5343 .padding(1)
5344 .kernel_size(3, 3)
5345 .stride(2)
5346 .groups(2)
5347 .group_input_channels(input_channels)
5348 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5349 .iterations(1)
5350 .TestF32();
5351 }
5352}
5353
5354TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_varying_output_channels) {
5355 ASSERT_EQ(xnn_status_success, xnn_initialize());
5356 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
5357 DeconvolutionOperatorTester()
5358 .input_size(10, 9)
5359 .padding(1)
5360 .kernel_size(3, 3)
5361 .stride(2)
5362 .groups(2)
5363 .group_input_channels(17)
5364 .group_output_channels(output_channels)
5365 .iterations(1)
5366 .TestF32();
5367 }
5368}
5369
5370TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_with_input_stride) {
5371 ASSERT_EQ(xnn_status_success, xnn_initialize());
5372 DeconvolutionOperatorTester()
5373 .input_size(10, 9)
5374 .padding(1)
5375 .kernel_size(3, 3)
5376 .stride(2)
5377 .groups(2)
5378 .group_input_channels(17)
5379 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5380 .input_pixel_stride(37)
5381 .iterations(3)
5382 .TestF32();
5383}
5384
5385TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_with_output_stride) {
5386 ASSERT_EQ(xnn_status_success, xnn_initialize());
5387 DeconvolutionOperatorTester()
5388 .input_size(10, 9)
5389 .padding(1)
5390 .kernel_size(3, 3)
5391 .stride(2)
5392 .groups(2)
5393 .group_input_channels(17)
5394 .group_output_channels(xnn_params.f32.gemm.nr + 3)
5395 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
5396 .iterations(3)
5397 .TestF32();
5398}
5399
5400TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_with_qmin) {
5401 ASSERT_EQ(xnn_status_success, xnn_initialize());
5402 DeconvolutionOperatorTester()
5403 .input_size(10, 9)
5404 .padding(1)
5405 .kernel_size(3, 3)
5406 .stride(2)
5407 .groups(2)
5408 .group_input_channels(17)
5409 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5410 .qmin(128)
5411 .iterations(3)
5412 .TestF32();
5413}
5414
5415TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_with_qmax) {
5416 ASSERT_EQ(xnn_status_success, xnn_initialize());
5417 DeconvolutionOperatorTester()
5418 .input_size(10, 9)
5419 .padding(1)
5420 .kernel_size(3, 3)
5421 .stride(2)
5422 .groups(2)
5423 .group_input_channels(17)
5424 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5425 .qmin(128)
5426 .iterations(3)
5427 .TestF32();
5428}
5429
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]5430TEST(DECONVOLUTION_OP_F32, grouped_3x3s2_without_bias) {
5431 ASSERT_EQ(xnn_status_success, xnn_initialize());
5432 DeconvolutionOperatorTester()
5433 .has_bias(false)
5434 .input_size(10, 9)
5435 .padding(1)
5436 .kernel_size(3, 3)
5437 .stride(2)
5438 .groups(2)
5439 .group_input_channels(17)
5440 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5441 .iterations(3)
5442 .TestF32();
5443}
5444
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]5445/**************************** SUBCONV2D path, batched ****************************/
5446
5447TEST(DECONVOLUTION_OP_F32, batched_3x3s2) {
5448 ASSERT_EQ(xnn_status_success, xnn_initialize());
5449 DeconvolutionOperatorTester()
5450 .batch_size(2)
5451 .input_size(10, 9)
5452 .padding(1)
5453 .kernel_size(3, 3)
5454 .stride(2)
5455 .group_input_channels(15)
5456 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5457 .iterations(3)
5458 .TestF32();
5459}
5460
5461TEST(DECONVOLUTION_OP_F32, batched_Kx3s2) {
5462 ASSERT_EQ(xnn_status_success, xnn_initialize());
5463 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
5464 DeconvolutionOperatorTester()
5465 .batch_size(2)
5466 .input_size(10, 9)
5467 .padding_width(1)
5468 .kernel_size(kernel_height, 3)
5469 .stride(2)
5470 .group_input_channels(17)
5471 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5472 .iterations(3)
5473 .TestF32();
5474 }
5475}
5476
5477TEST(DECONVOLUTION_OP_F32, batched_3xKs2) {
5478 ASSERT_EQ(xnn_status_success, xnn_initialize());
5479 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
5480 DeconvolutionOperatorTester()
5481 .batch_size(2)
5482 .input_size(10, 9)
5483 .padding_height(1)
5484 .kernel_size(3, kernel_width)
5485 .stride(2)
5486 .group_input_channels(17)
5487 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5488 .iterations(3)
5489 .TestF32();
5490 }
5491}
5492
5493TEST(DECONVOLUTION_OP_F32, batched_3x3sSx1) {
5494 ASSERT_EQ(xnn_status_success, xnn_initialize());
5495 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
5496 DeconvolutionOperatorTester()
5497 .batch_size(2)
5498 .input_size(10, 9)
5499 .padding(1)
5500 .padding_width(1)
5501 .kernel_size(3, 3)
5502 .stride_height(stride_height)
5503 .group_input_channels(17)
5504 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5505 .iterations(3)
5506 .TestF32();
5507 }
5508}
5509
5510TEST(DECONVOLUTION_OP_F32, batched_3x3s1xS) {
5511 ASSERT_EQ(xnn_status_success, xnn_initialize());
5512 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
5513 DeconvolutionOperatorTester()
5514 .batch_size(2)
5515 .input_size(10, 9)
5516 .padding(1)
5517 .padding_width(1)
5518 .kernel_size(3, 3)
5519 .stride_width(stride_width)
5520 .group_input_channels(17)
5521 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5522 .iterations(3)
5523 .TestF32();
5524 }
5525}
5526
5527TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_height_padding) {
5528 ASSERT_EQ(xnn_status_success, xnn_initialize());
5529 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
5530 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
5531 DeconvolutionOperatorTester()
5532 .batch_size(2)
5533 .input_size(10, 9)
5534 .padding_width(1)
5535 .padding_top(padding_top)
5536 .padding_bottom(padding_bottom)
5537 .kernel_size(3, 3)
5538 .stride(2)
5539 .group_input_channels(15)
5540 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5541 .iterations(1)
5542 .TestF32();
5543 }
5544 }
5545}
5546
5547TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_width_padding) {
5548 ASSERT_EQ(xnn_status_success, xnn_initialize());
5549 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
5550 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
5551 DeconvolutionOperatorTester()
5552 .batch_size(2)
5553 .input_size(10, 9)
5554 .padding_height(1)
5555 .padding_left(padding_left)
5556 .padding_right(padding_right)
5557 .kernel_size(3, 3)
5558 .stride(2)
5559 .group_input_channels(15)
5560 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5561 .iterations(1)
5562 .TestF32();
5563 }
5564 }
5565}
5566
5567TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_height_adjustment) {
5568 ASSERT_EQ(xnn_status_success, xnn_initialize());
5569 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
5570 DeconvolutionOperatorTester()
5571 .batch_size(2)
5572 .input_size(10, 9)
5573 .padding(1)
5574 .adjustment_height(adjustment_height)
5575 .kernel_size(3, 3)
5576 .stride(2)
5577 .group_input_channels(15)
5578 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5579 .iterations(1)
5580 .TestF32();
5581 }
5582}
5583
5584TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_width_adjustment) {
5585 ASSERT_EQ(xnn_status_success, xnn_initialize());
5586 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
5587 DeconvolutionOperatorTester()
5588 .batch_size(2)
5589 .input_size(10, 9)
5590 .padding(1)
5591 .adjustment_width(adjustment_width)
5592 .kernel_size(3, 3)
5593 .stride(2)
5594 .group_input_channels(15)
5595 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5596 .iterations(1)
5597 .TestF32();
5598 }
5599}
5600
5601TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_input_height) {
5602 ASSERT_EQ(xnn_status_success, xnn_initialize());
5603 for (size_t input_height = 8; input_height <= 12; input_height++) {
5604 DeconvolutionOperatorTester()
5605 .batch_size(2)
5606 .input_size(input_height, 9)
5607 .padding(1)
5608 .kernel_size(3, 3)
5609 .stride(2)
5610 .group_input_channels(15)
5611 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5612 .iterations(1)
5613 .TestF32();
5614 }
5615}
5616
5617TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_input_width) {
5618 ASSERT_EQ(xnn_status_success, xnn_initialize());
5619 for (size_t input_width = 7; input_width <= 11; input_width++) {
5620 DeconvolutionOperatorTester()
5621 .batch_size(2)
5622 .input_size(10, input_width)
5623 .padding(1)
5624 .kernel_size(3, 3)
5625 .stride(2)
5626 .group_input_channels(15)
5627 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5628 .iterations(1)
5629 .TestF32();
5630 }
5631}
5632
5633TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_input_channels) {
5634 ASSERT_EQ(xnn_status_success, xnn_initialize());
5635 for (size_t input_channels = 1; input_channels <= 16; input_channels *= 4) {
5636 DeconvolutionOperatorTester()
5637 .batch_size(2)
5638 .input_size(10, 9)
5639 .padding(1)
5640 .kernel_size(3, 3)
5641 .stride(2)
5642 .group_input_channels(input_channels)
5643 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5644 .iterations(1)
5645 .TestF32();
5646 }
5647}
5648
5649TEST(DECONVOLUTION_OP_F32, batched_3x3s2_varying_output_channels) {
5650 ASSERT_EQ(xnn_status_success, xnn_initialize());
5651 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
5652 DeconvolutionOperatorTester()
5653 .batch_size(2)
5654 .input_size(10, 9)
5655 .padding(1)
5656 .kernel_size(3, 3)
5657 .stride(2)
5658 .group_input_channels(23)
5659 .group_output_channels(output_channels)
5660 .iterations(1)
5661 .TestF32();
5662 }
5663}
5664
5665TEST(DECONVOLUTION_OP_F32, batched_3x3s2_with_input_stride) {
5666 ASSERT_EQ(xnn_status_success, xnn_initialize());
5667 DeconvolutionOperatorTester()
5668 .batch_size(2)
5669 .input_size(10, 9)
5670 .padding(1)
5671 .kernel_size(3, 3)
5672 .stride(2)
5673 .group_input_channels(23)
5674 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5675 .input_pixel_stride(28)
5676 .iterations(3)
5677 .TestF32();
5678}
5679
5680TEST(DECONVOLUTION_OP_F32, batched_3x3s2_with_output_stride) {
5681 ASSERT_EQ(xnn_status_success, xnn_initialize());
5682 DeconvolutionOperatorTester()
5683 .batch_size(2)
5684 .input_size(10, 9)
5685 .padding(1)
5686 .kernel_size(3, 3)
5687 .stride(2)
5688 .group_input_channels(23)
5689 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5690 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
5691 .iterations(3)
5692 .TestF32();
5693}
5694
5695TEST(DECONVOLUTION_OP_F32, batched_3x3s2_with_qmin) {
5696 ASSERT_EQ(xnn_status_success, xnn_initialize());
5697 DeconvolutionOperatorTester()
5698 .batch_size(2)
5699 .input_size(10, 9)
5700 .padding(1)
5701 .kernel_size(3, 3)
5702 .stride(2)
5703 .group_input_channels(23)
5704 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5705 .qmin(128)
5706 .iterations(3)
5707 .TestF32();
5708}
5709
5710TEST(DECONVOLUTION_OP_F32, batched_3x3s2_with_qmax) {
5711 ASSERT_EQ(xnn_status_success, xnn_initialize());
5712 DeconvolutionOperatorTester()
5713 .batch_size(2)
5714 .input_size(10, 9)
5715 .padding(1)
5716 .kernel_size(3, 3)
5717 .stride(2)
5718 .group_input_channels(23)
5719 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5720 .qmin(128)
5721 .iterations(3)
5722 .TestF32();
5723}
5724
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]5725TEST(DECONVOLUTION_OP_F32, batched_3x3s2_without_bias) {
5726 ASSERT_EQ(xnn_status_success, xnn_initialize());
5727 DeconvolutionOperatorTester()
5728 .has_bias(false)
5729 .batch_size(2)
5730 .input_size(10, 9)
5731 .padding(1)
5732 .kernel_size(3, 3)
5733 .stride(2)
5734 .group_input_channels(23)
5735 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5736 .iterations(3)
5737 .TestF32();
5738}
5739
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]5740/**************************** SUBCONV2D path, grouped, batched ****************************/
5741
5742TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2) {
5743 ASSERT_EQ(xnn_status_success, xnn_initialize());
5744 DeconvolutionOperatorTester()
5745 .batch_size(2)
5746 .input_size(10, 9)
5747 .padding(1)
5748 .kernel_size(3, 3)
5749 .stride(2)
5750 .groups(2)
5751 .group_input_channels(17)
5752 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5753 .iterations(3)
5754 .TestF32();
5755}
5756
5757TEST(DECONVOLUTION_OP_F32, batched_grouped_Kx3s2) {
5758 ASSERT_EQ(xnn_status_success, xnn_initialize());
5759 for (size_t kernel_height = 2; kernel_height <= 5; kernel_height++) {
5760 DeconvolutionOperatorTester()
5761 .batch_size(2)
5762 .input_size(10, 9)
5763 .padding_width(1)
5764 .kernel_size(kernel_height, 3)
5765 .stride(2)
5766 .groups(2)
5767 .group_input_channels(17)
5768 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5769 .iterations(3)
5770 .TestF32();
5771 }
5772}
5773
5774TEST(DECONVOLUTION_OP_F32, batched_grouped_3xKs2) {
5775 ASSERT_EQ(xnn_status_success, xnn_initialize());
5776 for (size_t kernel_width = 2; kernel_width <= 5; kernel_width++) {
5777 DeconvolutionOperatorTester()
5778 .batch_size(2)
5779 .input_size(10, 9)
5780 .padding_height(1)
5781 .kernel_size(3, kernel_width)
5782 .stride(2)
5783 .groups(2)
5784 .group_input_channels(17)
5785 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5786 .iterations(3)
5787 .TestF32();
5788 }
5789}
5790
5791TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3sSx1) {
5792 ASSERT_EQ(xnn_status_success, xnn_initialize());
5793 for (size_t stride_height = 2; stride_height <= 3; stride_height++) {
5794 DeconvolutionOperatorTester()
5795 .batch_size(2)
5796 .input_size(10, 9)
5797 .padding(1)
5798 .padding_width(1)
5799 .kernel_size(3, 3)
5800 .stride_height(stride_height)
5801 .groups(2)
5802 .group_input_channels(17)
5803 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5804 .iterations(3)
5805 .TestF32();
5806 }
5807}
5808
5809TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s1xS) {
5810 ASSERT_EQ(xnn_status_success, xnn_initialize());
5811 for (size_t stride_width = 2; stride_width <= 3; stride_width++) {
5812 DeconvolutionOperatorTester()
5813 .batch_size(2)
5814 .input_size(10, 9)
5815 .padding(1)
5816 .padding_width(1)
5817 .kernel_size(3, 3)
5818 .stride_width(stride_width)
5819 .groups(2)
5820 .group_input_channels(17)
5821 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5822 .iterations(3)
5823 .TestF32();
5824 }
5825}
5826
5827TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_height_padding) {
5828 ASSERT_EQ(xnn_status_success, xnn_initialize());
5829 for (size_t padding_top = 0; padding_top <= 2; padding_top++) {
5830 for (size_t padding_bottom = 0; padding_bottom <= 2; padding_bottom++) {
5831 DeconvolutionOperatorTester()
5832 .batch_size(2)
5833 .input_size(10, 9)
5834 .padding_width(1)
5835 .padding_top(padding_top)
5836 .padding_bottom(padding_bottom)
5837 .kernel_size(3, 3)
5838 .stride(2)
5839 .groups(2)
5840 .group_input_channels(17)
5841 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5842 .iterations(1)
5843 .TestF32();
5844 }
5845 }
5846}
5847
5848TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_width_padding) {
5849 ASSERT_EQ(xnn_status_success, xnn_initialize());
5850 for (size_t padding_left = 0; padding_left <= 2; padding_left++) {
5851 for (size_t padding_right = 0; padding_right <= 2; padding_right++) {
5852 DeconvolutionOperatorTester()
5853 .batch_size(2)
5854 .input_size(10, 9)
5855 .padding_height(1)
5856 .padding_left(padding_left)
5857 .padding_right(padding_right)
5858 .kernel_size(3, 3)
5859 .stride(2)
5860 .groups(2)
5861 .group_input_channels(17)
5862 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5863 .iterations(1)
5864 .TestF32();
5865 }
5866 }
5867}
5868
5869TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_height_adjustment) {
5870 ASSERT_EQ(xnn_status_success, xnn_initialize());
5871 for (size_t adjustment_height = 1; adjustment_height <= 2; adjustment_height++) {
5872 DeconvolutionOperatorTester()
5873 .batch_size(2)
5874 .input_size(10, 9)
5875 .padding(1)
5876 .adjustment_height(adjustment_height)
5877 .kernel_size(3, 3)
5878 .stride(2)
5879 .groups(2)
5880 .group_input_channels(17)
5881 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5882 .iterations(1)
5883 .TestF32();
5884 }
5885}
5886
5887TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_width_adjustment) {
5888 ASSERT_EQ(xnn_status_success, xnn_initialize());
5889 for (size_t adjustment_width = 1; adjustment_width <= 2; adjustment_width++) {
5890 DeconvolutionOperatorTester()
5891 .batch_size(2)
5892 .input_size(10, 9)
5893 .padding(1)
5894 .adjustment_width(adjustment_width)
5895 .kernel_size(3, 3)
5896 .stride(2)
5897 .groups(2)
5898 .group_input_channels(17)
5899 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5900 .iterations(1)
5901 .TestF32();
5902 }
5903}
5904
5905TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_input_height) {
5906 ASSERT_EQ(xnn_status_success, xnn_initialize());
5907 for (size_t input_height = 8; input_height <= 12; input_height++) {
5908 DeconvolutionOperatorTester()
5909 .batch_size(2)
5910 .input_size(input_height, 9)
5911 .padding(1)
5912 .kernel_size(3, 3)
5913 .stride(2)
5914 .groups(2)
5915 .group_input_channels(17)
5916 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5917 .iterations(1)
5918 .TestF32();
5919 }
5920}
5921
5922TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_input_width) {
5923 ASSERT_EQ(xnn_status_success, xnn_initialize());
5924 for (size_t input_width = 7; input_width <= 11; input_width++) {
5925 DeconvolutionOperatorTester()
5926 .batch_size(2)
5927 .input_size(10, input_width)
5928 .padding(1)
5929 .kernel_size(3, 3)
5930 .stride(2)
5931 .groups(2)
5932 .group_input_channels(17)
5933 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5934 .iterations(1)
5935 .TestF32();
5936 }
5937}
5938
5939TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_input_channels) {
5940 ASSERT_EQ(xnn_status_success, xnn_initialize());
5941 for (size_t input_channels = 14; input_channels <= 20; input_channels++) {
5942 DeconvolutionOperatorTester()
5943 .batch_size(2)
5944 .input_size(10, 9)
5945 .padding(1)
5946 .kernel_size(3, 3)
5947 .stride(2)
5948 .groups(2)
5949 .group_input_channels(input_channels)
5950 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5951 .iterations(1)
5952 .TestF32();
5953 }
5954}
5955
5956TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_varying_output_channels) {
5957 ASSERT_EQ(xnn_status_success, xnn_initialize());
5958 for (size_t output_channels = 1; output_channels <= xnn_params.f32.gemm.nr * 2; output_channels *= 2) {
5959 DeconvolutionOperatorTester()
5960 .batch_size(2)
5961 .input_size(10, 9)
5962 .padding(1)
5963 .kernel_size(3, 3)
5964 .stride(2)
5965 .groups(2)
5966 .group_input_channels(17)
5967 .group_output_channels(output_channels)
5968 .iterations(1)
5969 .TestF32();
5970 }
5971}
5972
5973TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_with_input_stride) {
5974 ASSERT_EQ(xnn_status_success, xnn_initialize());
5975 DeconvolutionOperatorTester()
5976 .batch_size(2)
5977 .input_size(10, 9)
5978 .padding(1)
5979 .kernel_size(3, 3)
5980 .stride(2)
5981 .groups(2)
5982 .group_input_channels(17)
5983 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
5984 .input_pixel_stride(37)
5985 .iterations(3)
5986 .TestF32();
5987}
5988
5989TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_with_output_stride) {
5990 ASSERT_EQ(xnn_status_success, xnn_initialize());
5991 DeconvolutionOperatorTester()
5992 .batch_size(2)
5993 .input_size(10, 9)
5994 .padding(1)
5995 .kernel_size(3, 3)
5996 .stride(2)
5997 .groups(2)
5998 .group_input_channels(17)
5999 .group_output_channels(xnn_params.f32.gemm.nr + 3)
6000 .output_pixel_stride(xnn_params.f32.gemm.nr * 2 + 13)
6001 .iterations(3)
6002 .TestF32();
6003}
6004
6005TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_with_qmin) {
6006 ASSERT_EQ(xnn_status_success, xnn_initialize());
6007 DeconvolutionOperatorTester()
6008 .batch_size(2)
6009 .input_size(10, 9)
6010 .padding(1)
6011 .kernel_size(3, 3)
6012 .stride(2)
6013 .groups(2)
6014 .group_input_channels(17)
6015 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
6016 .qmin(128)
6017 .iterations(3)
6018 .TestF32();
6019}
6020
6021TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_with_qmax) {
6022 ASSERT_EQ(xnn_status_success, xnn_initialize());
6023 DeconvolutionOperatorTester()
6024 .batch_size(2)
6025 .input_size(10, 9)
6026 .padding(1)
6027 .kernel_size(3, 3)
6028 .stride(2)
6029 .groups(2)
6030 .group_input_channels(17)
6031 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
6032 .qmin(128)
6033 .iterations(3)
6034 .TestF32();
6035}
6036
Marat Dukhanf568f082019-10-30 09:47:07 -0700[diff] [blame^]6037TEST(DECONVOLUTION_OP_F32, batched_grouped_3x3s2_without_bias) {
6038 ASSERT_EQ(xnn_status_success, xnn_initialize());
6039 DeconvolutionOperatorTester()
6040 .has_bias(false)
6041 .batch_size(2)
6042 .input_size(10, 9)
6043 .padding(1)
6044 .kernel_size(3, 3)
6045 .stride(2)
6046 .groups(2)
6047 .group_input_channels(17)
6048 .group_output_channels(xnn_params.f32.gemm.nr * 2 + 3)
6049 .iterations(3)
6050 .TestF32();
6051}
6052
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]6053/**************************** SUBCONV2D path, setup ****************************/
6054
6055TEST(DECONVOLUTION_OP_F32, 3x3s2_setup_changing_batch) {
6056 ASSERT_EQ(xnn_status_success, xnn_initialize());
6057 DeconvolutionOperatorTester()
6058 .batch_size(2)
6059 .next_batch_size(5)
6060 .input_height(8)
6061 .input_width(9)
6062 .kernel_height(3)
6063 .kernel_width(5)
6064 .stride(2)
6065 .groups(2)
6066 .group_input_channels(15)
6067 .group_output_channels(17)
6068 .TestSetupF32();
6069}
6070
6071TEST(DECONVOLUTION_OP_F32, 3x3s2_setup_changing_height) {
6072 ASSERT_EQ(xnn_status_success, xnn_initialize());
6073 DeconvolutionOperatorTester()
6074 .batch_size(2)
6075 .input_height(8)
6076 .input_width(9)
6077 .next_input_height(10)
6078 .kernel_height(3)
6079 .kernel_width(5)
6080 .stride(2)
6081 .groups(2)
6082 .group_input_channels(15)
6083 .group_output_channels(17)
6084 .TestSetupF32();
6085}
6086
6087TEST(DECONVOLUTION_OP_F32, 3x3s2_setup_changing_width) {
6088 ASSERT_EQ(xnn_status_success, xnn_initialize());
6089 DeconvolutionOperatorTester()
6090 .batch_size(2)
6091 .input_height(8)
6092 .input_width(9)
6093 .next_input_width(10)
6094 .kernel_height(3)
6095 .kernel_width(5)
6096 .stride(2)
6097 .groups(2)
6098 .group_input_channels(15)
6099 .group_output_channels(17)
6100 .TestSetupF32();
6101}