1 /* Copyright 2021 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 <limits>
19 #include <memory>
20 #include <random>
21
22 #include <gtest/gtest.h>
23 #include "tensorflow/lite/delegates/xnnpack/quantized_binary_elementwise_tester.h"
24 #include "tensorflow/lite/delegates/xnnpack/xnnpack_delegate.h"
25
26 namespace tflite {
27 namespace xnnpack {
28
29 TEST(UnsignedQuantizedSub, 4DBy4D) {
30 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
31 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
32 TfLiteXNNPackDelegateDelete);
33
34 std::random_device random_device;
35 auto rng = std::mt19937(random_device());
36 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
37 std::numeric_limits<uint8_t>::min(),
38 std::numeric_limits<uint8_t>::max()),
39 std::ref(rng));
40 auto shape_rng =
41 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
42 const auto batch = shape_rng();
43 const auto height = shape_rng();
44 const auto width = shape_rng();
45 const auto channels = shape_rng();
46
47 QuantizedBinaryElementwiseTester()
48 .Unsigned(true)
49 .Input1ZeroPoint(zero_point_rng())
50 .Input2ZeroPoint(zero_point_rng())
51 .OutputZeroPoint(zero_point_rng())
52 .Input1Shape({batch, height, width, channels})
53 .Input2Shape({batch, height, width, channels})
54 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
55 }
56
57 TEST(UnsignedQuantizedSub, 4DBy4DBroadcastChannels) {
58 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
59 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
60 TfLiteXNNPackDelegateDelete);
61
62 std::random_device random_device;
63 auto rng = std::mt19937(random_device());
64 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
65 std::numeric_limits<uint8_t>::min(),
66 std::numeric_limits<uint8_t>::max()),
67 std::ref(rng));
68 auto shape_rng =
69 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
70 const auto batch = shape_rng();
71 const auto height = shape_rng();
72 const auto width = shape_rng();
73 const auto channels = shape_rng();
74
75 QuantizedBinaryElementwiseTester()
76 .Unsigned(true)
77 .Input1ZeroPoint(zero_point_rng())
78 .Input2ZeroPoint(zero_point_rng())
79 .OutputZeroPoint(zero_point_rng())
80 .Input1Shape({1, 1, 1, channels})
81 .Input2Shape({batch, height, width, channels})
82 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
83
84 QuantizedBinaryElementwiseTester()
85 .Unsigned(true)
86 .Input1ZeroPoint(zero_point_rng())
87 .Input2ZeroPoint(zero_point_rng())
88 .OutputZeroPoint(zero_point_rng())
89 .Input1Shape({batch, height, width, channels})
90 .Input2Shape({1, 1, 1, channels})
91 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
92 }
93
94 TEST(UnsignedQuantizedSub, 4DBy4DBroadcastWidth) {
95 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
96 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
97 TfLiteXNNPackDelegateDelete);
98
99 std::random_device random_device;
100 auto rng = std::mt19937(random_device());
101 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
102 std::numeric_limits<uint8_t>::min(),
103 std::numeric_limits<uint8_t>::max()),
104 std::ref(rng));
105 auto shape_rng =
106 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
107 const auto batch = shape_rng();
108 const auto height = shape_rng();
109 const auto width = shape_rng();
110 const auto channels = shape_rng();
111
112 QuantizedBinaryElementwiseTester()
113 .Unsigned(true)
114 .Input1ZeroPoint(zero_point_rng())
115 .Input2ZeroPoint(zero_point_rng())
116 .OutputZeroPoint(zero_point_rng())
117 .Input1Shape({1, 1, width, 1})
118 .Input2Shape({batch, height, width, channels})
119 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
120
121 QuantizedBinaryElementwiseTester()
122 .Unsigned(true)
123 .Input1ZeroPoint(zero_point_rng())
124 .Input2ZeroPoint(zero_point_rng())
125 .OutputZeroPoint(zero_point_rng())
126 .Input1Shape({batch, height, width, channels})
127 .Input2Shape({1, 1, width, 1})
128 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
129 }
130
131 TEST(UnsignedQuantizedSub, 4DBy4DBroadcastHeight) {
132 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
133 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
134 TfLiteXNNPackDelegateDelete);
135
136 std::random_device random_device;
137 auto rng = std::mt19937(random_device());
138 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
139 std::numeric_limits<uint8_t>::min(),
140 std::numeric_limits<uint8_t>::max()),
141 std::ref(rng));
142 auto shape_rng =
143 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
144 const auto batch = shape_rng();
145 const auto height = shape_rng();
146 const auto width = shape_rng();
147 const auto channels = shape_rng();
148
149 QuantizedBinaryElementwiseTester()
150 .Unsigned(true)
151 .Input1ZeroPoint(zero_point_rng())
152 .Input2ZeroPoint(zero_point_rng())
153 .OutputZeroPoint(zero_point_rng())
154 .Input1Shape({1, height, 1, 1})
155 .Input2Shape({batch, height, width, channels})
156 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
157
158 QuantizedBinaryElementwiseTester()
159 .Unsigned(true)
160 .Input1ZeroPoint(zero_point_rng())
161 .Input2ZeroPoint(zero_point_rng())
162 .OutputZeroPoint(zero_point_rng())
163 .Input1Shape({batch, height, width, channels})
164 .Input2Shape({1, height, 1, 1})
165 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
166 }
167
168 TEST(UnsignedQuantizedSub, 4DBy4DBroadcastBatch) {
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 zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
176 std::numeric_limits<uint8_t>::min(),
177 std::numeric_limits<uint8_t>::max()),
178 std::ref(rng));
179 auto shape_rng =
180 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
181 const auto batch = shape_rng();
182 const auto height = shape_rng();
183 const auto width = shape_rng();
184 const auto channels = shape_rng();
185
186 QuantizedBinaryElementwiseTester()
187 .Unsigned(true)
188 .Input1ZeroPoint(zero_point_rng())
189 .Input2ZeroPoint(zero_point_rng())
190 .OutputZeroPoint(zero_point_rng())
191 .Input1Shape({batch, 1, 1, 1})
192 .Input2Shape({batch, height, width, channels})
193 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
194
195 QuantizedBinaryElementwiseTester()
196 .Unsigned(true)
197 .Input1ZeroPoint(zero_point_rng())
198 .Input2ZeroPoint(zero_point_rng())
199 .OutputZeroPoint(zero_point_rng())
200 .Input1Shape({batch, height, width, channels})
201 .Input2Shape({batch, 1, 1, 1})
202 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
203 }
204
205 TEST(UnsignedQuantizedSub, 4DBy4DBroadcastHeightWidthChannels) {
206 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
207 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
208 TfLiteXNNPackDelegateDelete);
209
210 std::random_device random_device;
211 auto rng = std::mt19937(random_device());
212 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
213 std::numeric_limits<uint8_t>::min(),
214 std::numeric_limits<uint8_t>::max()),
215 std::ref(rng));
216 auto shape_rng =
217 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
218 const auto batch = shape_rng();
219 const auto height = shape_rng();
220 const auto width = shape_rng();
221 const auto channels = shape_rng();
222
223 QuantizedBinaryElementwiseTester()
224 .Unsigned(true)
225 .Input1ZeroPoint(zero_point_rng())
226 .Input2ZeroPoint(zero_point_rng())
227 .OutputZeroPoint(zero_point_rng())
228 .Input1Shape({1, height, width, channels})
229 .Input2Shape({batch, height, width, channels})
230 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
231
232 QuantizedBinaryElementwiseTester()
233 .Unsigned(true)
234 .Input1ZeroPoint(zero_point_rng())
235 .Input2ZeroPoint(zero_point_rng())
236 .OutputZeroPoint(zero_point_rng())
237 .Input1Shape({batch, height, width, channels})
238 .Input2Shape({1, height, width, channels})
239 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
240 }
241
242 TEST(UnsignedQuantizedSub, 4DBy3D) {
243 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
244 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
245 TfLiteXNNPackDelegateDelete);
246
247 std::random_device random_device;
248 auto rng = std::mt19937(random_device());
249 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
250 std::numeric_limits<uint8_t>::min(),
251 std::numeric_limits<uint8_t>::max()),
252 std::ref(rng));
253 auto shape_rng =
254 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
255 const auto batch = shape_rng();
256 const auto height = shape_rng();
257 const auto width = shape_rng();
258 const auto channels = shape_rng();
259
260 QuantizedBinaryElementwiseTester()
261 .Unsigned(true)
262 .Input1ZeroPoint(zero_point_rng())
263 .Input2ZeroPoint(zero_point_rng())
264 .OutputZeroPoint(zero_point_rng())
265 .Input1Shape({height, width, channels})
266 .Input2Shape({batch, height, width, channels})
267 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
268
269 QuantizedBinaryElementwiseTester()
270 .Unsigned(true)
271 .Input1ZeroPoint(zero_point_rng())
272 .Input2ZeroPoint(zero_point_rng())
273 .OutputZeroPoint(zero_point_rng())
274 .Input1Shape({batch, height, width, channels})
275 .Input2Shape({height, width, channels})
276 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
277 }
278
279 TEST(UnsignedQuantizedSub, 4DBy2D) {
280 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
281 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
282 TfLiteXNNPackDelegateDelete);
283
284 std::random_device random_device;
285 auto rng = std::mt19937(random_device());
286 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
287 std::numeric_limits<uint8_t>::min(),
288 std::numeric_limits<uint8_t>::max()),
289 std::ref(rng));
290 auto shape_rng =
291 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
292 const auto batch = shape_rng();
293 const auto height = shape_rng();
294 const auto width = shape_rng();
295 const auto channels = shape_rng();
296
297 QuantizedBinaryElementwiseTester()
298 .Unsigned(true)
299 .Input1ZeroPoint(zero_point_rng())
300 .Input2ZeroPoint(zero_point_rng())
301 .OutputZeroPoint(zero_point_rng())
302 .Input1Shape({width, channels})
303 .Input2Shape({batch, height, width, channels})
304 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
305
306 QuantizedBinaryElementwiseTester()
307 .Unsigned(true)
308 .Input1ZeroPoint(zero_point_rng())
309 .Input2ZeroPoint(zero_point_rng())
310 .OutputZeroPoint(zero_point_rng())
311 .Input1Shape({batch, height, width, channels})
312 .Input2Shape({width, channels})
313 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
314 }
315
316 TEST(UnsignedQuantizedSub, 4DBy1D) {
317 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
318 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
319 TfLiteXNNPackDelegateDelete);
320
321 std::random_device random_device;
322 auto rng = std::mt19937(random_device());
323 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
324 std::numeric_limits<uint8_t>::min(),
325 std::numeric_limits<uint8_t>::max()),
326 std::ref(rng));
327 auto shape_rng =
328 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
329 const auto batch = shape_rng();
330 const auto height = shape_rng();
331 const auto width = shape_rng();
332 const auto channels = shape_rng();
333
334 QuantizedBinaryElementwiseTester()
335 .Unsigned(true)
336 .Input1ZeroPoint(zero_point_rng())
337 .Input2ZeroPoint(zero_point_rng())
338 .OutputZeroPoint(zero_point_rng())
339 .Input1Shape({channels})
340 .Input2Shape({batch, height, width, channels})
341 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
342
343 QuantizedBinaryElementwiseTester()
344 .Unsigned(true)
345 .Input1ZeroPoint(zero_point_rng())
346 .Input2ZeroPoint(zero_point_rng())
347 .OutputZeroPoint(zero_point_rng())
348 .Input1Shape({batch, height, width, channels})
349 .Input2Shape({channels})
350 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
351 }
352
353 TEST(UnsignedQuantizedSub, 4DBy0D) {
354 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
355 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
356 TfLiteXNNPackDelegateDelete);
357
358 std::random_device random_device;
359 auto rng = std::mt19937(random_device());
360 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
361 std::numeric_limits<uint8_t>::min(),
362 std::numeric_limits<uint8_t>::max()),
363 std::ref(rng));
364 auto shape_rng =
365 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
366 const auto batch = shape_rng();
367 const auto height = shape_rng();
368 const auto width = shape_rng();
369 const auto channels = shape_rng();
370
371 QuantizedBinaryElementwiseTester()
372 .Unsigned(true)
373 .Input1ZeroPoint(zero_point_rng())
374 .Input2ZeroPoint(zero_point_rng())
375 .OutputZeroPoint(zero_point_rng())
376 .Input1Shape({})
377 .Input2Shape({batch, height, width, channels})
378 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
379
380 QuantizedBinaryElementwiseTester()
381 .Unsigned(true)
382 .Input1ZeroPoint(zero_point_rng())
383 .Input2ZeroPoint(zero_point_rng())
384 .OutputZeroPoint(zero_point_rng())
385 .Input1Shape({batch, height, width, channels})
386 .Input2Shape({})
387 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
388 }
389
390 TEST(UnsignedQuantizedSub, 2DBy2D) {
391 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
392 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
393 TfLiteXNNPackDelegateDelete);
394
395 std::random_device random_device;
396 auto rng = std::mt19937(random_device());
397 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
398 std::numeric_limits<uint8_t>::min(),
399 std::numeric_limits<uint8_t>::max()),
400 std::ref(rng));
401 auto shape_rng =
402 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
403 const auto batch = shape_rng();
404 const auto channels = shape_rng();
405
406 QuantizedBinaryElementwiseTester()
407 .Unsigned(true)
408 .Input1ZeroPoint(zero_point_rng())
409 .Input2ZeroPoint(zero_point_rng())
410 .OutputZeroPoint(zero_point_rng())
411 .Input1Shape({batch, channels})
412 .Input2Shape({batch, channels})
413 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
414 }
415
416 TEST(UnsignedQuantizedSub, 2DBy1D) {
417 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
418 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
419 TfLiteXNNPackDelegateDelete);
420
421 std::random_device random_device;
422 auto rng = std::mt19937(random_device());
423 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
424 std::numeric_limits<uint8_t>::min(),
425 std::numeric_limits<uint8_t>::max()),
426 std::ref(rng));
427 auto shape_rng =
428 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
429 const auto batch = shape_rng();
430 const auto channels = shape_rng();
431
432 QuantizedBinaryElementwiseTester()
433 .Unsigned(true)
434 .Input1ZeroPoint(zero_point_rng())
435 .Input2ZeroPoint(zero_point_rng())
436 .OutputZeroPoint(zero_point_rng())
437 .Input1Shape({channels})
438 .Input2Shape({batch, channels})
439 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
440
441 QuantizedBinaryElementwiseTester()
442 .Unsigned(true)
443 .Input1ZeroPoint(zero_point_rng())
444 .Input2ZeroPoint(zero_point_rng())
445 .OutputZeroPoint(zero_point_rng())
446 .Input1Shape({batch, channels})
447 .Input2Shape({channels})
448 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
449 }
450
451 TEST(UnsignedQuantizedSub, 2DBy0D) {
452 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
453 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
454 TfLiteXNNPackDelegateDelete);
455
456 std::random_device random_device;
457 auto rng = std::mt19937(random_device());
458 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
459 std::numeric_limits<uint8_t>::min(),
460 std::numeric_limits<uint8_t>::max()),
461 std::ref(rng));
462 auto shape_rng =
463 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
464 const auto batch = shape_rng();
465 const auto channels = shape_rng();
466
467 QuantizedBinaryElementwiseTester()
468 .Unsigned(true)
469 .Input1ZeroPoint(zero_point_rng())
470 .Input2ZeroPoint(zero_point_rng())
471 .OutputZeroPoint(zero_point_rng())
472 .Input1Shape({})
473 .Input2Shape({batch, channels})
474 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
475
476 QuantizedBinaryElementwiseTester()
477 .Unsigned(true)
478 .Input1ZeroPoint(zero_point_rng())
479 .Input2ZeroPoint(zero_point_rng())
480 .OutputZeroPoint(zero_point_rng())
481 .Input1Shape({batch, channels})
482 .Input2Shape({})
483 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
484 }
485
486 TEST(UnsignedQuantizedSub, 4DByStatic4D) {
487 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
488 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
489 TfLiteXNNPackDelegateDelete);
490
491 std::random_device random_device;
492 auto rng = std::mt19937(random_device());
493 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
494 std::numeric_limits<uint8_t>::min(),
495 std::numeric_limits<uint8_t>::max()),
496 std::ref(rng));
497 auto shape_rng =
498 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
499 const auto batch = shape_rng();
500 const auto height = shape_rng();
501 const auto width = shape_rng();
502 const auto channels = shape_rng();
503
504 QuantizedBinaryElementwiseTester()
505 .Unsigned(true)
506 .Input1ZeroPoint(zero_point_rng())
507 .Input2ZeroPoint(zero_point_rng())
508 .OutputZeroPoint(zero_point_rng())
509 .Input1Shape({batch, height, width, channels})
510 .Input2Shape({batch, height, width, channels})
511 .Input1Static(true)
512 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
513
514 QuantizedBinaryElementwiseTester()
515 .Unsigned(true)
516 .Input1ZeroPoint(zero_point_rng())
517 .Input2ZeroPoint(zero_point_rng())
518 .OutputZeroPoint(zero_point_rng())
519 .Input1Shape({batch, height, width, channels})
520 .Input2Shape({batch, height, width, channels})
521 .Input2Static(true)
522 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
523 }
524
525 TEST(UnsignedQuantizedSub, 4DByStatic4DBroadcastChannels) {
526 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
527 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
528 TfLiteXNNPackDelegateDelete);
529
530 std::random_device random_device;
531 auto rng = std::mt19937(random_device());
532 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
533 std::numeric_limits<uint8_t>::min(),
534 std::numeric_limits<uint8_t>::max()),
535 std::ref(rng));
536 auto shape_rng =
537 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
538 const auto batch = shape_rng();
539 const auto height = shape_rng();
540 const auto width = shape_rng();
541 const auto channels = shape_rng();
542
543 QuantizedBinaryElementwiseTester()
544 .Unsigned(true)
545 .Input1ZeroPoint(zero_point_rng())
546 .Input2ZeroPoint(zero_point_rng())
547 .OutputZeroPoint(zero_point_rng())
548 .Input1Shape({1, 1, 1, channels})
549 .Input2Shape({batch, height, width, channels})
550 .Input1Static(true)
551 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
552
553 QuantizedBinaryElementwiseTester()
554 .Unsigned(true)
555 .Input1ZeroPoint(zero_point_rng())
556 .Input2ZeroPoint(zero_point_rng())
557 .OutputZeroPoint(zero_point_rng())
558 .Input1Shape({batch, height, width, channels})
559 .Input2Shape({1, 1, 1, channels})
560 .Input2Static(true)
561 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
562 }
563
564 TEST(UnsignedQuantizedSub, 4DByStatic4DBroadcastWidth) {
565 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
566 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
567 TfLiteXNNPackDelegateDelete);
568
569 std::random_device random_device;
570 auto rng = std::mt19937(random_device());
571 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
572 std::numeric_limits<uint8_t>::min(),
573 std::numeric_limits<uint8_t>::max()),
574 std::ref(rng));
575 auto shape_rng =
576 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
577 const auto batch = shape_rng();
578 const auto height = shape_rng();
579 const auto width = shape_rng();
580 const auto channels = shape_rng();
581
582 QuantizedBinaryElementwiseTester()
583 .Unsigned(true)
584 .Input1ZeroPoint(zero_point_rng())
585 .Input2ZeroPoint(zero_point_rng())
586 .OutputZeroPoint(zero_point_rng())
587 .Input1Shape({1, 1, width, 1})
588 .Input2Shape({batch, height, width, channels})
589 .Input1Static(true)
590 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
591
592 QuantizedBinaryElementwiseTester()
593 .Unsigned(true)
594 .Input1ZeroPoint(zero_point_rng())
595 .Input2ZeroPoint(zero_point_rng())
596 .OutputZeroPoint(zero_point_rng())
597 .Input1Shape({batch, height, width, channels})
598 .Input2Shape({1, 1, width, 1})
599 .Input2Static(true)
600 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
601 }
602
603 TEST(UnsignedQuantizedSub, 4DByStatic4DBroadcastHeight) {
604 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
605 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
606 TfLiteXNNPackDelegateDelete);
607
608 std::random_device random_device;
609 auto rng = std::mt19937(random_device());
610 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
611 std::numeric_limits<uint8_t>::min(),
612 std::numeric_limits<uint8_t>::max()),
613 std::ref(rng));
614 auto shape_rng =
615 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
616 const auto batch = shape_rng();
617 const auto height = shape_rng();
618 const auto width = shape_rng();
619 const auto channels = shape_rng();
620
621 QuantizedBinaryElementwiseTester()
622 .Unsigned(true)
623 .Input1ZeroPoint(zero_point_rng())
624 .Input2ZeroPoint(zero_point_rng())
625 .OutputZeroPoint(zero_point_rng())
626 .Input1Shape({1, height, 1, 1})
627 .Input2Shape({batch, height, width, channels})
628 .Input1Static(true)
629 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
630
631 QuantizedBinaryElementwiseTester()
632 .Unsigned(true)
633 .Input1ZeroPoint(zero_point_rng())
634 .Input2ZeroPoint(zero_point_rng())
635 .OutputZeroPoint(zero_point_rng())
636 .Input1Shape({batch, height, width, channels})
637 .Input2Shape({1, height, 1, 1})
638 .Input2Static(true)
639 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
640 }
641
642 TEST(UnsignedQuantizedSub, 4DByStatic4DBroadcastBatch) {
643 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
644 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
645 TfLiteXNNPackDelegateDelete);
646
647 std::random_device random_device;
648 auto rng = std::mt19937(random_device());
649 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
650 std::numeric_limits<uint8_t>::min(),
651 std::numeric_limits<uint8_t>::max()),
652 std::ref(rng));
653 auto shape_rng =
654 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
655 const auto batch = shape_rng();
656 const auto height = shape_rng();
657 const auto width = shape_rng();
658 const auto channels = shape_rng();
659
660 QuantizedBinaryElementwiseTester()
661 .Unsigned(true)
662 .Input1ZeroPoint(zero_point_rng())
663 .Input2ZeroPoint(zero_point_rng())
664 .OutputZeroPoint(zero_point_rng())
665 .Input1Shape({batch, 1, 1, 1})
666 .Input2Shape({batch, height, width, channels})
667 .Input1Static(true)
668 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
669
670 QuantizedBinaryElementwiseTester()
671 .Unsigned(true)
672 .Input1ZeroPoint(zero_point_rng())
673 .Input2ZeroPoint(zero_point_rng())
674 .OutputZeroPoint(zero_point_rng())
675 .Input1Shape({batch, height, width, channels})
676 .Input2Shape({batch, 1, 1, 1})
677 .Input2Static(true)
678 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
679 }
680
681 TEST(UnsignedQuantizedSub, 4DByStatic4DBroadcastHeightWidthChannels) {
682 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
683 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
684 TfLiteXNNPackDelegateDelete);
685
686 std::random_device random_device;
687 auto rng = std::mt19937(random_device());
688 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
689 std::numeric_limits<uint8_t>::min(),
690 std::numeric_limits<uint8_t>::max()),
691 std::ref(rng));
692 auto shape_rng =
693 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
694 const auto batch = shape_rng();
695 const auto height = shape_rng();
696 const auto width = shape_rng();
697 const auto channels = shape_rng();
698
699 QuantizedBinaryElementwiseTester()
700 .Unsigned(true)
701 .Input1ZeroPoint(zero_point_rng())
702 .Input2ZeroPoint(zero_point_rng())
703 .OutputZeroPoint(zero_point_rng())
704 .Input1Shape({1, height, width, channels})
705 .Input2Shape({batch, height, width, channels})
706 .Input1Static(true)
707 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
708
709 QuantizedBinaryElementwiseTester()
710 .Unsigned(true)
711 .Input1ZeroPoint(zero_point_rng())
712 .Input2ZeroPoint(zero_point_rng())
713 .OutputZeroPoint(zero_point_rng())
714 .Input1Shape({batch, height, width, channels})
715 .Input2Shape({1, height, width, channels})
716 .Input2Static(true)
717 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
718 }
719
720 TEST(UnsignedQuantizedSub, 4DByStatic3D) {
721 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
722 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
723 TfLiteXNNPackDelegateDelete);
724
725 std::random_device random_device;
726 auto rng = std::mt19937(random_device());
727 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
728 std::numeric_limits<uint8_t>::min(),
729 std::numeric_limits<uint8_t>::max()),
730 std::ref(rng));
731 auto shape_rng =
732 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
733 const auto batch = shape_rng();
734 const auto height = shape_rng();
735 const auto width = shape_rng();
736 const auto channels = shape_rng();
737
738 QuantizedBinaryElementwiseTester()
739 .Unsigned(true)
740 .Input1ZeroPoint(zero_point_rng())
741 .Input2ZeroPoint(zero_point_rng())
742 .OutputZeroPoint(zero_point_rng())
743 .Input1Shape({height, width, channels})
744 .Input2Shape({batch, height, width, channels})
745 .Input1Static(true)
746 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
747
748 QuantizedBinaryElementwiseTester()
749 .Unsigned(true)
750 .Input1ZeroPoint(zero_point_rng())
751 .Input2ZeroPoint(zero_point_rng())
752 .OutputZeroPoint(zero_point_rng())
753 .Input1Shape({batch, height, width, channels})
754 .Input2Shape({height, width, channels})
755 .Input2Static(true)
756 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
757 }
758
759 TEST(UnsignedQuantizedSub, 4DByStatic2D) {
760 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
761 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
762 TfLiteXNNPackDelegateDelete);
763
764 std::random_device random_device;
765 auto rng = std::mt19937(random_device());
766 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
767 std::numeric_limits<uint8_t>::min(),
768 std::numeric_limits<uint8_t>::max()),
769 std::ref(rng));
770 auto shape_rng =
771 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
772 const auto batch = shape_rng();
773 const auto height = shape_rng();
774 const auto width = shape_rng();
775 const auto channels = shape_rng();
776
777 QuantizedBinaryElementwiseTester()
778 .Unsigned(true)
779 .Input1ZeroPoint(zero_point_rng())
780 .Input2ZeroPoint(zero_point_rng())
781 .OutputZeroPoint(zero_point_rng())
782 .Input1Shape({width, channels})
783 .Input2Shape({batch, height, width, channels})
784 .Input1Static(true)
785 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
786
787 QuantizedBinaryElementwiseTester()
788 .Unsigned(true)
789 .Input1ZeroPoint(zero_point_rng())
790 .Input2ZeroPoint(zero_point_rng())
791 .OutputZeroPoint(zero_point_rng())
792 .Input1Shape({batch, height, width, channels})
793 .Input2Shape({width, channels})
794 .Input2Static(true)
795 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
796 }
797
798 TEST(UnsignedQuantizedSub, 4DByStatic1D) {
799 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
800 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
801 TfLiteXNNPackDelegateDelete);
802
803 std::random_device random_device;
804 auto rng = std::mt19937(random_device());
805 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
806 std::numeric_limits<uint8_t>::min(),
807 std::numeric_limits<uint8_t>::max()),
808 std::ref(rng));
809 auto shape_rng =
810 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
811 const auto batch = shape_rng();
812 const auto height = shape_rng();
813 const auto width = shape_rng();
814 const auto channels = shape_rng();
815
816 QuantizedBinaryElementwiseTester()
817 .Unsigned(true)
818 .Input1ZeroPoint(zero_point_rng())
819 .Input2ZeroPoint(zero_point_rng())
820 .OutputZeroPoint(zero_point_rng())
821 .Input1Shape({channels})
822 .Input2Shape({batch, height, width, channels})
823 .Input1Static(true)
824 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
825
826 QuantizedBinaryElementwiseTester()
827 .Unsigned(true)
828 .Input1ZeroPoint(zero_point_rng())
829 .Input2ZeroPoint(zero_point_rng())
830 .OutputZeroPoint(zero_point_rng())
831 .Input1Shape({batch, height, width, channels})
832 .Input2Shape({channels})
833 .Input2Static(true)
834 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
835 }
836
837 TEST(UnsignedQuantizedSub, 4DByStatic0D) {
838 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
839 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
840 TfLiteXNNPackDelegateDelete);
841
842 std::random_device random_device;
843 auto rng = std::mt19937(random_device());
844 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
845 std::numeric_limits<uint8_t>::min(),
846 std::numeric_limits<uint8_t>::max()),
847 std::ref(rng));
848 auto shape_rng =
849 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
850 const auto batch = shape_rng();
851 const auto height = shape_rng();
852 const auto width = shape_rng();
853 const auto channels = shape_rng();
854
855 QuantizedBinaryElementwiseTester()
856 .Unsigned(true)
857 .Input1ZeroPoint(zero_point_rng())
858 .Input2ZeroPoint(zero_point_rng())
859 .OutputZeroPoint(zero_point_rng())
860 .Input1Shape({})
861 .Input2Shape({batch, height, width, channels})
862 .Input1Static(true)
863 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
864
865 QuantizedBinaryElementwiseTester()
866 .Unsigned(true)
867 .Input1ZeroPoint(zero_point_rng())
868 .Input2ZeroPoint(zero_point_rng())
869 .OutputZeroPoint(zero_point_rng())
870 .Input1Shape({batch, height, width, channels})
871 .Input2Shape({})
872 .Input2Static(true)
873 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
874 }
875
876 TEST(UnsignedQuantizedSub, 2DByStatic2D) {
877 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
878 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
879 TfLiteXNNPackDelegateDelete);
880
881 std::random_device random_device;
882 auto rng = std::mt19937(random_device());
883 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
884 std::numeric_limits<uint8_t>::min(),
885 std::numeric_limits<uint8_t>::max()),
886 std::ref(rng));
887 auto shape_rng =
888 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
889 const auto batch = shape_rng();
890 const auto channels = shape_rng();
891
892 QuantizedBinaryElementwiseTester()
893 .Unsigned(true)
894 .Input1ZeroPoint(zero_point_rng())
895 .Input2ZeroPoint(zero_point_rng())
896 .OutputZeroPoint(zero_point_rng())
897 .Input1Shape({batch, channels})
898 .Input2Shape({batch, channels})
899 .Input1Static(true)
900 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
901
902 QuantizedBinaryElementwiseTester()
903 .Unsigned(true)
904 .Input1ZeroPoint(zero_point_rng())
905 .Input2ZeroPoint(zero_point_rng())
906 .OutputZeroPoint(zero_point_rng())
907 .Input1Shape({batch, channels})
908 .Input2Shape({batch, channels})
909 .Input2Static(true)
910 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
911 }
912
913 TEST(UnsignedQuantizedSub, 2DByStatic1D) {
914 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
915 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
916 TfLiteXNNPackDelegateDelete);
917
918 std::random_device random_device;
919 auto rng = std::mt19937(random_device());
920 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
921 std::numeric_limits<uint8_t>::min(),
922 std::numeric_limits<uint8_t>::max()),
923 std::ref(rng));
924 auto shape_rng =
925 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
926 const auto batch = shape_rng();
927 const auto channels = shape_rng();
928
929 QuantizedBinaryElementwiseTester()
930 .Unsigned(true)
931 .Input1ZeroPoint(zero_point_rng())
932 .Input2ZeroPoint(zero_point_rng())
933 .OutputZeroPoint(zero_point_rng())
934 .Input1Shape({channels})
935 .Input2Shape({batch, channels})
936 .Input1Static(true)
937 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
938
939 QuantizedBinaryElementwiseTester()
940 .Unsigned(true)
941 .Input1ZeroPoint(zero_point_rng())
942 .Input2ZeroPoint(zero_point_rng())
943 .OutputZeroPoint(zero_point_rng())
944 .Input1Shape({batch, channels})
945 .Input2Shape({channels})
946 .Input2Static(true)
947 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
948 }
949
950 TEST(UnsignedQuantizedSub, 2DByStatic0D) {
951 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
952 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
953 TfLiteXNNPackDelegateDelete);
954
955 std::random_device random_device;
956 auto rng = std::mt19937(random_device());
957 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
958 std::numeric_limits<uint8_t>::min(),
959 std::numeric_limits<uint8_t>::max()),
960 std::ref(rng));
961 auto shape_rng =
962 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
963 const auto batch = shape_rng();
964 const auto channels = shape_rng();
965
966 QuantizedBinaryElementwiseTester()
967 .Unsigned(true)
968 .Input1ZeroPoint(zero_point_rng())
969 .Input2ZeroPoint(zero_point_rng())
970 .OutputZeroPoint(zero_point_rng())
971 .Input1Shape({})
972 .Input2Shape({batch, channels})
973 .Input1Static(true)
974 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
975
976 QuantizedBinaryElementwiseTester()
977 .Unsigned(true)
978 .Input1ZeroPoint(zero_point_rng())
979 .Input2ZeroPoint(zero_point_rng())
980 .OutputZeroPoint(zero_point_rng())
981 .Input1Shape({batch, channels})
982 .Input2Shape({})
983 .Input2Static(true)
984 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
985 }
986
TEST(UnsignedQuantizedSub,ReluActivation)987 TEST(UnsignedQuantizedSub, ReluActivation) {
988 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
989 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
990 TfLiteXNNPackDelegateDelete);
991
992 std::random_device random_device;
993 auto rng = std::mt19937(random_device());
994 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
995 std::numeric_limits<uint8_t>::min(),
996 std::numeric_limits<uint8_t>::max()),
997 std::ref(rng));
998 // Avoid degenerate situation when
999 // output_min == output_max == std::numeric_limits<uint8_t>::max()
1000 auto output_zero_point_rng =
1001 std::bind(std::uniform_int_distribution<int32_t>(
1002 std::numeric_limits<uint8_t>::min(),
1003 std::numeric_limits<uint8_t>::max() - 1),
1004 std::ref(rng));
1005 auto shape_rng =
1006 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
1007 const auto batch = shape_rng();
1008 const auto height = shape_rng();
1009 const auto width = shape_rng();
1010 const auto channels = shape_rng();
1011
1012 QuantizedBinaryElementwiseTester()
1013 .Unsigned(true)
1014 .Input1ZeroPoint(zero_point_rng())
1015 .Input2ZeroPoint(zero_point_rng())
1016 .OutputZeroPoint(output_zero_point_rng())
1017 .Input1Shape({batch, height, width, channels})
1018 .Input2Shape({batch, height, width, channels})
1019 .ReluActivation()
1020 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
1021 }
1022
TEST(UnsignedQuantizedSub,Relu6Activation)1023 TEST(UnsignedQuantizedSub, Relu6Activation) {
1024 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
1025 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
1026 TfLiteXNNPackDelegateDelete);
1027
1028 std::random_device random_device;
1029 auto rng = std::mt19937(random_device());
1030 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
1031 std::numeric_limits<uint8_t>::min(),
1032 std::numeric_limits<uint8_t>::max()),
1033 std::ref(rng));
1034 // Avoid degenerate situation when
1035 // output_min == output_max == std::numeric_limits<uint8_t>::max()
1036 auto output_zero_point_rng =
1037 std::bind(std::uniform_int_distribution<int32_t>(
1038 std::numeric_limits<uint8_t>::min(),
1039 std::numeric_limits<uint8_t>::max() - 1),
1040 std::ref(rng));
1041 auto shape_rng =
1042 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
1043 const auto batch = shape_rng();
1044 const auto height = shape_rng();
1045 const auto width = shape_rng();
1046 const auto channels = shape_rng();
1047
1048 QuantizedBinaryElementwiseTester()
1049 .Unsigned(true)
1050 .Input1ZeroPoint(zero_point_rng())
1051 .Input2ZeroPoint(zero_point_rng())
1052 .OutputZeroPoint(output_zero_point_rng())
1053 .Input1Shape({batch, height, width, channels})
1054 .Input2Shape({batch, height, width, channels})
1055 .Relu6Activation()
1056 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
1057 }
1058
TEST(UnsignedQuantizedSub,ReluMinus1To1Activation)1059 TEST(UnsignedQuantizedSub, ReluMinus1To1Activation) {
1060 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
1061 xnnpack_delegate(TfLiteXNNPackDelegateCreate(nullptr),
1062 TfLiteXNNPackDelegateDelete);
1063
1064 std::random_device random_device;
1065 auto rng = std::mt19937(random_device());
1066 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
1067 std::numeric_limits<uint8_t>::min(),
1068 std::numeric_limits<uint8_t>::max()),
1069 std::ref(rng));
1070 auto shape_rng =
1071 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
1072 const auto batch = shape_rng();
1073 const auto height = shape_rng();
1074 const auto width = shape_rng();
1075 const auto channels = shape_rng();
1076
1077 QuantizedBinaryElementwiseTester()
1078 .Unsigned(true)
1079 .Input1ZeroPoint(zero_point_rng())
1080 .Input2ZeroPoint(zero_point_rng())
1081 .OutputZeroPoint(zero_point_rng())
1082 .Input1Shape({batch, height, width, channels})
1083 .Input2Shape({batch, height, width, channels})
1084 .ReluMinus1To1Activation()
1085 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
1086 }
1087
TEST(UnsignedQuantizedSub,MultiThreading)1088 TEST(UnsignedQuantizedSub, MultiThreading) {
1089 TfLiteXNNPackDelegateOptions delegate_options =
1090 TfLiteXNNPackDelegateOptionsDefault();
1091 delegate_options.num_threads = 2;
1092 std::unique_ptr<TfLiteDelegate, decltype(&TfLiteXNNPackDelegateDelete)>
1093 xnnpack_delegate(TfLiteXNNPackDelegateCreate(&delegate_options),
1094 TfLiteXNNPackDelegateDelete);
1095
1096 std::random_device random_device;
1097 auto rng = std::mt19937(random_device());
1098 auto zero_point_rng = std::bind(std::uniform_int_distribution<int32_t>(
1099 std::numeric_limits<uint8_t>::min(),
1100 std::numeric_limits<uint8_t>::max()),
1101 std::ref(rng));
1102 auto shape_rng =
1103 std::bind(std::uniform_int_distribution<int32_t>(2, 5), std::ref(rng));
1104 const auto batch = shape_rng();
1105 const auto height = shape_rng();
1106 const auto width = shape_rng();
1107 const auto channels = shape_rng();
1108
1109 QuantizedBinaryElementwiseTester()
1110 .Unsigned(true)
1111 .Input1ZeroPoint(zero_point_rng())
1112 .Input2ZeroPoint(zero_point_rng())
1113 .OutputZeroPoint(zero_point_rng())
1114 .Input1Shape({batch, height, width, channels})
1115 .Input2Shape({batch, height, width, channels})
1116 .Test(BuiltinOperator_SUB, xnnpack_delegate.get());
1117 }
1118
1119 } // namespace xnnpack
1120 } // namespace tflite
1121