1 /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #include <cstdint>
17 #include <functional>
18 #include <memory>
19 #include <random>
20
21 #include <gtest/gtest.h>
22 #include "tensorflow/lite/delegates/xnnpack/quantized_pad_tester.h"
23 #include "tensorflow/lite/delegates/xnnpack/xnnpack_delegate.h"
24
25 namespace tflite {
26 namespace xnnpack {
27
TEST(UnsignedQuantizedPad,Full4D)28 TEST(UnsignedQuantizedPad, Full4D) {
29 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
30 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
31 TfLiteXNNPackDelegateDelete);
32
33 std::random_device random_device;
34 auto rng = std::mt19937(random_device());
35 auto pad_rng =
36 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
37 auto shape_rng =
38 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
39
40 QuantizedPadTester()
41 .Unsigned(true)
42 .InputPrePaddings({pad_rng(), pad_rng(), pad_rng(), pad_rng()})
43 .InputPostPaddings({pad_rng(), pad_rng(), pad_rng(), pad_rng()})
44 .InputShape({shape_rng(), shape_rng(), shape_rng(), shape_rng()})
45 .Test(xnnpack_delegate.get());
46 }
47
TEST(UnsignedQuantizedPad,Batch4D)48 TEST(UnsignedQuantizedPad, Batch4D) {
49 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
50 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
51 TfLiteXNNPackDelegateDelete);
52
53 std::random_device random_device;
54 auto rng = std::mt19937(random_device());
55 auto pad_rng =
56 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
57 auto shape_rng =
58 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
59
60 QuantizedPadTester()
61 .Unsigned(true)
62 .InputPrePaddings({pad_rng(), 0, 0, 0})
63 .InputPostPaddings({pad_rng(), 0, 0, 0})
64 .InputShape({shape_rng(), shape_rng(), shape_rng(), shape_rng()})
65 .Test(xnnpack_delegate.get());
66 }
67
TEST(UnsignedQuantizedPad,HeightAndWidth4D)68 TEST(UnsignedQuantizedPad, HeightAndWidth4D) {
69 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
70 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
71 TfLiteXNNPackDelegateDelete);
72
73 std::random_device random_device;
74 auto rng = std::mt19937(random_device());
75 auto pad_rng =
76 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
77 auto shape_rng =
78 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
79
80 QuantizedPadTester()
81 .Unsigned(true)
82 .InputPrePaddings({0, pad_rng(), pad_rng(), 0})
83 .InputPostPaddings({0, pad_rng(), pad_rng(), 0})
84 .InputShape({shape_rng(), shape_rng(), shape_rng(), shape_rng()})
85 .Test(xnnpack_delegate.get());
86 }
87
TEST(UnsignedQuantizedPad,Channels4D)88 TEST(UnsignedQuantizedPad, Channels4D) {
89 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
90 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
91 TfLiteXNNPackDelegateDelete);
92
93 std::random_device random_device;
94 auto rng = std::mt19937(random_device());
95 auto pad_rng =
96 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
97 auto shape_rng =
98 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
99
100 QuantizedPadTester()
101 .Unsigned(true)
102 .InputPrePaddings({0, 0, 0, pad_rng()})
103 .InputPostPaddings({0, 0, 0, pad_rng()})
104 .InputShape({shape_rng(), shape_rng(), shape_rng(), shape_rng()})
105 .Test(xnnpack_delegate.get());
106 }
107
TEST(UnsignedQuantizedPad,Full3D)108 TEST(UnsignedQuantizedPad, Full3D) {
109 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
110 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
111 TfLiteXNNPackDelegateDelete);
112
113 std::random_device random_device;
114 auto rng = std::mt19937(random_device());
115 auto pad_rng =
116 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
117 auto shape_rng =
118 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
119
120 QuantizedPadTester()
121 .Unsigned(true)
122 .InputPrePaddings({pad_rng(), pad_rng(), pad_rng()})
123 .InputPostPaddings({pad_rng(), pad_rng(), pad_rng()})
124 .InputShape({shape_rng(), shape_rng(), shape_rng()})
125 .Test(xnnpack_delegate.get());
126 }
127
TEST(UnsignedQuantizedPad,Batch3D)128 TEST(UnsignedQuantizedPad, Batch3D) {
129 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
130 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
131 TfLiteXNNPackDelegateDelete);
132
133 std::random_device random_device;
134 auto rng = std::mt19937(random_device());
135 auto pad_rng =
136 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
137 auto shape_rng =
138 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
139
140 QuantizedPadTester()
141 .Unsigned(true)
142 .InputPrePaddings({pad_rng(), 0, 0})
143 .InputPostPaddings({pad_rng(), 0, 0})
144 .InputShape({shape_rng(), shape_rng(), shape_rng()})
145 .Test(xnnpack_delegate.get());
146 }
147
TEST(UnsignedQuantizedPad,Width3D)148 TEST(UnsignedQuantizedPad, Width3D) {
149 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
150 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
151 TfLiteXNNPackDelegateDelete);
152
153 std::random_device random_device;
154 auto rng = std::mt19937(random_device());
155 auto pad_rng =
156 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
157 auto shape_rng =
158 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
159
160 QuantizedPadTester()
161 .Unsigned(true)
162 .InputPrePaddings({0, pad_rng(), 0})
163 .InputPostPaddings({0, pad_rng(), 0})
164 .InputShape({shape_rng(), shape_rng(), shape_rng()})
165 .Test(xnnpack_delegate.get());
166 }
167
TEST(UnsignedQuantizedPad,Channels3D)168 TEST(UnsignedQuantizedPad, Channels3D) {
169 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
170 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
171 TfLiteXNNPackDelegateDelete);
172
173 std::random_device random_device;
174 auto rng = std::mt19937(random_device());
175 auto pad_rng =
176 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
177 auto shape_rng =
178 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
179
180 QuantizedPadTester()
181 .Unsigned(true)
182 .InputPrePaddings({0, 0, pad_rng()})
183 .InputPostPaddings({0, 0, pad_rng()})
184 .InputShape({shape_rng(), shape_rng(), shape_rng()})
185 .Test(xnnpack_delegate.get());
186 }
187
TEST(UnsignedQuantizedPad,Full2D)188 TEST(UnsignedQuantizedPad, Full2D) {
189 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
190 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
191 TfLiteXNNPackDelegateDelete);
192
193 std::random_device random_device;
194 auto rng = std::mt19937(random_device());
195 auto pad_rng =
196 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
197 auto shape_rng =
198 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
199
200 QuantizedPadTester()
201 .Unsigned(true)
202 .InputPrePaddings({pad_rng(), pad_rng()})
203 .InputPostPaddings({pad_rng(), pad_rng()})
204 .InputShape({shape_rng(), shape_rng()})
205 .Test(xnnpack_delegate.get());
206 }
207
TEST(UnsignedQuantizedPad,Batch2D)208 TEST(UnsignedQuantizedPad, Batch2D) {
209 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
210 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
211 TfLiteXNNPackDelegateDelete);
212
213 std::random_device random_device;
214 auto rng = std::mt19937(random_device());
215 auto pad_rng =
216 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
217 auto shape_rng =
218 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
219
220 QuantizedPadTester()
221 .Unsigned(true)
222 .InputPrePaddings({pad_rng(), 0})
223 .InputPostPaddings({pad_rng(), 0})
224 .InputShape({shape_rng(), shape_rng()})
225 .Test(xnnpack_delegate.get());
226 }
227
TEST(UnsignedQuantizedPad,Channels2D)228 TEST(UnsignedQuantizedPad, Channels2D) {
229 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
230 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
231 TfLiteXNNPackDelegateDelete);
232
233 std::random_device random_device;
234 auto rng = std::mt19937(random_device());
235 auto pad_rng =
236 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
237 auto shape_rng =
238 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
239
240 QuantizedPadTester()
241 .Unsigned(true)
242 .InputPrePaddings({0, pad_rng()})
243 .InputPostPaddings({0, pad_rng()})
244 .InputShape({shape_rng(), shape_rng()})
245 .Test(xnnpack_delegate.get());
246 }
247
248 TEST(UnsignedQuantizedPad, 1D) {
249 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
250 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
251 TfLiteXNNPackDelegateDelete);
252
253 std::random_device random_device;
254 auto rng = std::mt19937(random_device());
255 auto pad_rng =
256 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
257 auto shape_rng =
258 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
259
260 QuantizedPadTester()
261 .Unsigned(true)
262 .InputPrePaddings({pad_rng(), pad_rng()})
263 .InputPostPaddings({pad_rng(), pad_rng()})
264 .InputShape({shape_rng(), shape_rng()})
265 .Test(xnnpack_delegate.get());
266 }
267
TEST(UnsignedQuantizedPad,MultiThreading)268 TEST(UnsignedQuantizedPad, MultiThreading) {
269 TfLiteXNNPackDelegateOptions delegate_options =
270 TfLiteXNNPackDelegateOptionsDefault();
271 delegate_options.num_threads = 2;
272 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
273 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
274 TfLiteXNNPackDelegateDelete);
275
276 std::random_device random_device;
277 auto rng = std::mt19937(random_device());
278 auto pad_rng =
279 std::bind(std::uniform_int_distribution<int32_t>(1, 3), std::ref(rng));
280 auto shape_rng =
281 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
282
283 QuantizedPadTester()
284 .Unsigned(true)
285 .InputPrePaddings({0, 0, 0, pad_rng()})
286 .InputPostPaddings({0, 0, 0, pad_rng()})
287 .InputShape({shape_rng(), shape_rng(), shape_rng(), shape_rng()})
288 .Test(xnnpack_delegate.get());
289 }
290
291 } // namespace xnnpack
292 } // namespace tflite
293