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 "unpooling-operator-tester.h"
9
10
TEST(UNPOOLING_NHWC_X32,unit_height_horizontal_pool)11 TEST(UNPOOLING_NHWC_X32, unit_height_horizontal_pool) {
12 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
13 for (size_t channels = 1; channels <= 100; channels += 15) {
14 for (size_t pooling_size : std::vector<size_t>{{2, 3, 5, 7}}) {
15 UnpoolingOperatorTester()
16 .batch_size(1)
17 .input_height(1)
18 .input_width(7)
19 .pooling_height(1)
20 .pooling_width(pooling_size)
21 .channels(channels)
22 .TestX32();
23 }
24 }
25 }
26
TEST(UNPOOLING_NHWC_X32,unit_height_horizontal_pool_with_padding)27 TEST(UNPOOLING_NHWC_X32, unit_height_horizontal_pool_with_padding) {
28 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
29 for (size_t channels = 1; channels <= 100; channels += 15) {
30 for (size_t pooling_size : std::vector<size_t>{{3, 5, 7}}) {
31 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
32 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
33 UnpoolingOperatorTester()
34 .batch_size(1)
35 .input_height(1)
36 .input_width(7)
37 .padding_left(padding_left)
38 .padding_right(padding_right)
39 .pooling_height(1)
40 .pooling_width(pooling_size)
41 .channels(channels)
42 .TestX32();
43 }
44 }
45 }
46 }
47 }
48
TEST(UNPOOLING_NHWC_X32,unit_height_vertical_pool)49 TEST(UNPOOLING_NHWC_X32, unit_height_vertical_pool) {
50 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
51 for (size_t channels = 1; channels <= 100; channels += 15) {
52 for (size_t pooling_size : std::vector<size_t>{{2, 3, 5, 7}}) {
53 UnpoolingOperatorTester()
54 .batch_size(1)
55 .input_height(7)
56 .input_width(1)
57 .pooling_height(pooling_size)
58 .pooling_width(1)
59 .channels(channels)
60 .TestX32();
61 }
62 }
63 }
64
TEST(UNPOOLING_NHWC_X32,unit_height_vertical_pool_with_padding)65 TEST(UNPOOLING_NHWC_X32, unit_height_vertical_pool_with_padding) {
66 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
67 for (size_t channels = 1; channels <= 100; channels += 15) {
68 for (size_t pooling_size : std::vector<size_t>{{3, 5, 7}}) {
69 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
70 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
71 UnpoolingOperatorTester()
72 .batch_size(1)
73 .input_height(7)
74 .input_width(1)
75 .padding_top(padding_top)
76 .padding_bottom(padding_bottom)
77 .pooling_height(pooling_size)
78 .pooling_width(1)
79 .channels(channels)
80 .TestX32();
81 }
82 }
83 }
84 }
85 }
86
TEST(UNPOOLING_NHWC_X32,unit_height_square_pool)87 TEST(UNPOOLING_NHWC_X32, unit_height_square_pool) {
88 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
89 for (size_t channels = 1; channels <= 100; channels += 15) {
90 for (size_t pooling_size : std::vector<size_t>{{2, 3, 5}}) {
91 UnpoolingOperatorTester()
92 .batch_size(1)
93 .input_height(2)
94 .input_width(4)
95 .pooling_height(pooling_size)
96 .pooling_width(pooling_size)
97 .channels(channels)
98 .TestX32();
99 }
100 }
101 }
102
TEST(UNPOOLING_NHWC_X32,unit_height_3x3_pool_with_padding)103 TEST(UNPOOLING_NHWC_X32, unit_height_3x3_pool_with_padding) {
104 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
105 for (size_t channels = 1; channels <= 100; channels += 15) {
106 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
107 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
108 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
109 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
110 UnpoolingOperatorTester()
111 .batch_size(1)
112 .input_height(2)
113 .input_width(4)
114 .padding_left(padding_left)
115 .padding_top(padding_top)
116 .padding_right(padding_right)
117 .padding_bottom(padding_bottom)
118 .pooling_height(3)
119 .pooling_width(3)
120 .channels(channels)
121 .iterations(3)
122 .TestX32();
123 }
124 }
125 }
126 }
127 }
128 }
129
TEST(UNPOOLING_NHWC_X32,small_height_square_pool)130 TEST(UNPOOLING_NHWC_X32, small_height_square_pool) {
131 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
132 for (size_t channels = 1; channels <= 100; channels += 15) {
133 for (size_t pooling_size : std::vector<size_t>{{2, 3, 5}}) {
134 UnpoolingOperatorTester()
135 .batch_size(1)
136 .input_height(4)
137 .input_width(7)
138 .pooling_height(pooling_size)
139 .pooling_width(pooling_size)
140 .channels(channels)
141 .TestX32();
142 }
143 }
144 }
145
TEST(UNPOOLING_NHWC_X32,small_height_3x3_pool_with_input_stride)146 TEST(UNPOOLING_NHWC_X32, small_height_3x3_pool_with_input_stride) {
147 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
148 for (size_t channels = 1; channels <= 100; channels += 15) {
149 UnpoolingOperatorTester()
150 .batch_size(1)
151 .input_height(4)
152 .input_width(7)
153 .pooling_height(3)
154 .pooling_width(3)
155 .input_pixel_stride(channels * 2 + 1)
156 .channels(channels)
157 .TestX32();
158 }
159 }
160
TEST(UNPOOLING_NHWC_X32,small_height_3x3_pool_with_output_stride)161 TEST(UNPOOLING_NHWC_X32, small_height_3x3_pool_with_output_stride) {
162 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
163 for (size_t channels = 1; channels <= 100; channels += 15) {
164 UnpoolingOperatorTester()
165 .batch_size(1)
166 .input_height(4)
167 .input_width(7)
168 .pooling_height(3)
169 .pooling_width(3)
170 .output_pixel_stride(channels * 2 + 3)
171 .channels(channels)
172 .TestX32();
173 }
174 }
175
TEST(UNPOOLING_NHWC_X32,small_height_3x3_pool_with_padding)176 TEST(UNPOOLING_NHWC_X32, small_height_3x3_pool_with_padding) {
177 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
178 for (size_t channels = 1; channels <= 50; channels += 15) {
179 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
180 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
181 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
182 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
183 UnpoolingOperatorTester()
184 .batch_size(1)
185 .input_height(4)
186 .input_width(7)
187 .pooling_height(3)
188 .pooling_width(3)
189 .channels(channels)
190 .iterations(1)
191 .TestX32();
192 }
193 }
194 }
195 }
196 }
197 }
198
TEST(UNPOOLING_NHWC_X32,small_height_and_batch_square_pool)199 TEST(UNPOOLING_NHWC_X32, small_height_and_batch_square_pool) {
200 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
201 for (size_t channels = 1; channels <= 100; channels += 15) {
202 for (size_t pooling_size : std::vector<size_t>{{2, 3}}) {
203 UnpoolingOperatorTester()
204 .batch_size(3)
205 .input_height(4)
206 .input_width(7)
207 .pooling_height(pooling_size)
208 .pooling_width(pooling_size)
209 .channels(channels)
210 .TestX32();
211 }
212 }
213 }
214
TEST(UNPOOLING_NHWC_X32,setup_increasing_batch)215 TEST(UNPOOLING_NHWC_X32, setup_increasing_batch) {
216 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
217 UnpoolingOperatorTester()
218 .batch_size(3)
219 .next_batch_size(5)
220 .input_height(4)
221 .input_width(4)
222 .pooling_height(5)
223 .pooling_width(3)
224 .channels(24)
225 .TestSetupX32();
226 }
227
TEST(UNPOOLING_NHWC_X32,setup_decreasing_batch)228 TEST(UNPOOLING_NHWC_X32, setup_decreasing_batch) {
229 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
230 UnpoolingOperatorTester()
231 .batch_size(5)
232 .next_batch_size(3)
233 .input_height(4)
234 .input_width(4)
235 .pooling_height(5)
236 .pooling_width(3)
237 .channels(24)
238 .TestSetupX32();
239 }
240
TEST(UNPOOLING_NHWC_X32,setup_changing_height)241 TEST(UNPOOLING_NHWC_X32, setup_changing_height) {
242 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
243 UnpoolingOperatorTester()
244 .batch_size(3)
245 .input_height(4)
246 .input_width(4)
247 .next_input_height(9)
248 .pooling_height(5)
249 .pooling_width(3)
250 .channels(24)
251 .TestSetupX32();
252 UnpoolingOperatorTester()
253 .batch_size(3)
254 .input_height(4)
255 .input_width(4)
256 .next_input_height(7)
257 .pooling_height(5)
258 .pooling_width(3)
259 .channels(24)
260 .TestSetupX32();
261 }
262
TEST(UNPOOLING_NHWC_X32,setup_changing_width)263 TEST(UNPOOLING_NHWC_X32, setup_changing_width) {
264 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
265 UnpoolingOperatorTester()
266 .batch_size(3)
267 .input_height(4)
268 .input_width(4)
269 .next_input_width(9)
270 .pooling_height(5)
271 .pooling_width(3)
272 .channels(24)
273 .TestSetupX32();
274 UnpoolingOperatorTester()
275 .batch_size(3)
276 .input_height(4)
277 .input_width(4)
278 .next_input_width(7)
279 .pooling_height(5)
280 .pooling_width(3)
281 .channels(24)
282 .TestSetupX32();
283 }
284
TEST(UNPOOLING_NHWC_X32,setup_swap_height_and_width)285 TEST(UNPOOLING_NHWC_X32, setup_swap_height_and_width) {
286 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
287 UnpoolingOperatorTester()
288 .batch_size(3)
289 .input_height(5)
290 .input_width(4)
291 .next_input_height(4)
292 .next_input_width(5)
293 .pooling_height(5)
294 .pooling_width(3)
295 .channels(24)
296 .TestSetupX32();
297 }
298