1 // Copyright 2021 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 "convert-operator-tester.h"
9
10
TEST(CONVERT_NC_F16_F32,unit_batch)11 TEST(CONVERT_NC_F16_F32, unit_batch) {
12 for (size_t channels = 1; channels < 100; channels++) {
13 ConvertOperatorTester()
14 .batch_size(1)
15 .channels(channels)
16 .iterations(3)
17 .TestF16toF32();
18 }
19 }
20
TEST(CONVERT_NC_F16_F32,small_batch)21 TEST(CONVERT_NC_F16_F32, small_batch) {
22 for (size_t channels = 1; channels < 100; channels++) {
23 ConvertOperatorTester()
24 .batch_size(3)
25 .channels(channels)
26 .iterations(3)
27 .TestF16toF32();
28 }
29 }
30
TEST(CONVERT_NC_F16_F32,small_batch_with_input_stride)31 TEST(CONVERT_NC_F16_F32, small_batch_with_input_stride) {
32 for (size_t channels = 1; channels < 100; channels += 15) {
33 ConvertOperatorTester()
34 .batch_size(3)
35 .channels(channels)
36 .input_stride(129)
37 .iterations(3)
38 .TestF16toF32();
39 }
40 }
41
TEST(CONVERT_NC_F16_F32,small_batch_with_output_stride)42 TEST(CONVERT_NC_F16_F32, small_batch_with_output_stride) {
43 for (size_t channels = 1; channels < 100; channels += 15) {
44 ConvertOperatorTester()
45 .batch_size(3)
46 .channels(channels)
47 .output_stride(117)
48 .iterations(3)
49 .TestF16toF32();
50 }
51 }
52
TEST(CONVERT_NC_F16_F32,small_batch_with_input_and_output_stride)53 TEST(CONVERT_NC_F16_F32, small_batch_with_input_and_output_stride) {
54 for (size_t channels = 1; channels < 100; channels += 15) {
55 ConvertOperatorTester()
56 .batch_size(3)
57 .channels(channels)
58 .input_stride(129)
59 .output_stride(117)
60 .iterations(3)
61 .TestF16toF32();
62 }
63 }
64
TEST(CONVERT_NC_F32_F16,unit_batch)65 TEST(CONVERT_NC_F32_F16, unit_batch) {
66 for (size_t channels = 1; channels < 100; channels++) {
67 ConvertOperatorTester()
68 .batch_size(1)
69 .channels(channels)
70 .iterations(3)
71 .TestF32toF16();
72 }
73 }
74
TEST(CONVERT_NC_F32_F16,small_batch)75 TEST(CONVERT_NC_F32_F16, small_batch) {
76 for (size_t channels = 1; channels < 100; channels++) {
77 ConvertOperatorTester()
78 .batch_size(3)
79 .channels(channels)
80 .iterations(3)
81 .TestF32toF16();
82 }
83 }
84
TEST(CONVERT_NC_F32_F16,small_batch_with_input_stride)85 TEST(CONVERT_NC_F32_F16, small_batch_with_input_stride) {
86 for (size_t channels = 1; channels < 100; channels += 15) {
87 ConvertOperatorTester()
88 .batch_size(3)
89 .channels(channels)
90 .input_stride(129)
91 .iterations(3)
92 .TestF32toF16();
93 }
94 }
95
TEST(CONVERT_NC_F32_F16,small_batch_with_output_stride)96 TEST(CONVERT_NC_F32_F16, small_batch_with_output_stride) {
97 for (size_t channels = 1; channels < 100; channels += 15) {
98 ConvertOperatorTester()
99 .batch_size(3)
100 .channels(channels)
101 .output_stride(117)
102 .iterations(3)
103 .TestF32toF16();
104 }
105 }
106
TEST(CONVERT_NC_F32_F16,small_batch_with_input_and_output_stride)107 TEST(CONVERT_NC_F32_F16, small_batch_with_input_and_output_stride) {
108 for (size_t channels = 1; channels < 100; channels += 15) {
109 ConvertOperatorTester()
110 .batch_size(3)
111 .channels(channels)
112 .input_stride(129)
113 .output_stride(117)
114 .iterations(3)
115 .TestF32toF16();
116 }
117 }
118
TEST(CONVERT_NC_F32_QS8,unit_batch)119 TEST(CONVERT_NC_F32_QS8, unit_batch) {
120 for (size_t channels = 1; channels < 100; channels++) {
121 ConvertOperatorTester()
122 .batch_size(1)
123 .channels(channels)
124 .qmin(std::numeric_limits<int8_t>::min())
125 .qmax(std::numeric_limits<int8_t>::max())
126 .iterations(3)
127 .TestF32toQS8();
128 }
129 }
130
TEST(CONVERT_NC_F32_QS8,small_batch)131 TEST(CONVERT_NC_F32_QS8, small_batch) {
132 for (size_t channels = 1; channels < 100; channels++) {
133 ConvertOperatorTester()
134 .batch_size(3)
135 .channels(channels)
136 .qmin(std::numeric_limits<int8_t>::min())
137 .qmax(std::numeric_limits<int8_t>::max())
138 .iterations(3)
139 .TestF32toQS8();
140 }
141 }
142
TEST(CONVERT_NC_F32_QS8,small_batch_with_input_stride)143 TEST(CONVERT_NC_F32_QS8, small_batch_with_input_stride) {
144 for (size_t channels = 1; channels < 100; channels += 15) {
145 ConvertOperatorTester()
146 .batch_size(3)
147 .channels(channels)
148 .input_stride(129)
149 .qmin(std::numeric_limits<int8_t>::min())
150 .qmax(std::numeric_limits<int8_t>::max())
151 .iterations(3)
152 .TestF32toQS8();
153 }
154 }
155
TEST(CONVERT_NC_F32_QS8,small_batch_with_output_stride)156 TEST(CONVERT_NC_F32_QS8, small_batch_with_output_stride) {
157 for (size_t channels = 1; channels < 100; channels += 15) {
158 ConvertOperatorTester()
159 .batch_size(3)
160 .channels(channels)
161 .output_stride(117)
162 .qmin(std::numeric_limits<int8_t>::min())
163 .qmax(std::numeric_limits<int8_t>::max())
164 .iterations(3)
165 .TestF32toQS8();
166 }
167 }
168
TEST(CONVERT_NC_F32_QS8,small_batch_with_input_and_output_stride)169 TEST(CONVERT_NC_F32_QS8, small_batch_with_input_and_output_stride) {
170 for (size_t channels = 1; channels < 100; channels += 15) {
171 ConvertOperatorTester()
172 .batch_size(3)
173 .channels(channels)
174 .input_stride(129)
175 .output_stride(117)
176 .qmin(std::numeric_limits<int8_t>::min())
177 .qmax(std::numeric_limits<int8_t>::max())
178 .iterations(3)
179 .TestF32toQS8();
180 }
181 }
182
TEST(CONVERT_NC_F32_QS8,scale)183 TEST(CONVERT_NC_F32_QS8, scale) {
184 for (float scale : std::vector<float>{{0.1f, 1.0f, 10.0f}}) {
185 for (size_t channels = 1; channels < 100; channels++) {
186 ConvertOperatorTester()
187 .batch_size(3)
188 .channels(channels)
189 .scale(scale)
190 .qmin(std::numeric_limits<int8_t>::min())
191 .qmax(std::numeric_limits<int8_t>::max())
192 .iterations(3)
193 .TestF32toQS8();
194 }
195 }
196 }
197
TEST(CONVERT_NC_F32_QS8,output_zero_point)198 TEST(CONVERT_NC_F32_QS8, output_zero_point) {
199 for (int16_t zero_point = std::numeric_limits<int8_t>::min();
200 zero_point <= std::numeric_limits<int8_t>::max();
201 zero_point += 51)
202 {
203 for (size_t channels = 1; channels < 100; channels++) {
204 ConvertOperatorTester()
205 .batch_size(3)
206 .channels(channels)
207 .zero_point(zero_point)
208 .qmin(std::numeric_limits<int8_t>::min())
209 .qmax(std::numeric_limits<int8_t>::max())
210 .iterations(3)
211 .TestF32toQS8();
212 }
213 }
214 }
215
TEST(CONVERT_NC_F32_QS8,output_min)216 TEST(CONVERT_NC_F32_QS8, output_min) {
217 for (int16_t qmin = std::numeric_limits<int8_t>::min();
218 qmin < std::numeric_limits<int8_t>::max();
219 qmin += 51)
220 {
221 for (size_t channels = 1; channels < 100; channels++) {
222 ConvertOperatorTester()
223 .batch_size(3)
224 .channels(channels)
225 .qmin(qmin)
226 .qmax(std::numeric_limits<int8_t>::max())
227 .iterations(3)
228 .TestF32toQS8();
229 }
230 }
231 }
232
TEST(CONVERT_NC_F32_QS8,output_max)233 TEST(CONVERT_NC_F32_QS8, output_max) {
234 for (int16_t qmax = std::numeric_limits<int8_t>::min() + 1;
235 qmax <= std::numeric_limits<int8_t>::max();
236 qmax += 51)
237 {
238 for (size_t channels = 1; channels < 100; channels++) {
239 ConvertOperatorTester()
240 .batch_size(3)
241 .channels(channels)
242 .qmin(std::numeric_limits<int8_t>::min())
243 .qmax(qmax)
244 .iterations(3)
245 .TestF32toQS8();
246 }
247 }
248 }
249
TEST(CONVERT_NC_F32_QU8,unit_batch)250 TEST(CONVERT_NC_F32_QU8, unit_batch) {
251 for (size_t channels = 1; channels < 100; channels++) {
252 ConvertOperatorTester()
253 .batch_size(1)
254 .channels(channels)
255 .qmin(std::numeric_limits<uint8_t>::min())
256 .qmax(std::numeric_limits<uint8_t>::max())
257 .iterations(3)
258 .TestF32toQU8();
259 }
260 }
261
TEST(CONVERT_NC_F32_QU8,small_batch)262 TEST(CONVERT_NC_F32_QU8, small_batch) {
263 for (size_t channels = 1; channels < 100; channels++) {
264 ConvertOperatorTester()
265 .batch_size(3)
266 .channels(channels)
267 .qmin(std::numeric_limits<uint8_t>::min())
268 .qmax(std::numeric_limits<uint8_t>::max())
269 .iterations(3)
270 .TestF32toQU8();
271 }
272 }
273
TEST(CONVERT_NC_F32_QU8,small_batch_with_input_stride)274 TEST(CONVERT_NC_F32_QU8, small_batch_with_input_stride) {
275 for (size_t channels = 1; channels < 100; channels += 15) {
276 ConvertOperatorTester()
277 .batch_size(3)
278 .channels(channels)
279 .input_stride(129)
280 .qmin(std::numeric_limits<uint8_t>::min())
281 .qmax(std::numeric_limits<uint8_t>::max())
282 .iterations(3)
283 .TestF32toQU8();
284 }
285 }
286
TEST(CONVERT_NC_F32_QU8,small_batch_with_output_stride)287 TEST(CONVERT_NC_F32_QU8, small_batch_with_output_stride) {
288 for (size_t channels = 1; channels < 100; channels += 15) {
289 ConvertOperatorTester()
290 .batch_size(3)
291 .channels(channels)
292 .output_stride(117)
293 .qmin(std::numeric_limits<uint8_t>::min())
294 .qmax(std::numeric_limits<uint8_t>::max())
295 .iterations(3)
296 .TestF32toQU8();
297 }
298 }
299
TEST(CONVERT_NC_F32_QU8,small_batch_with_input_and_output_stride)300 TEST(CONVERT_NC_F32_QU8, small_batch_with_input_and_output_stride) {
301 for (size_t channels = 1; channels < 100; channels += 15) {
302 ConvertOperatorTester()
303 .batch_size(3)
304 .channels(channels)
305 .input_stride(129)
306 .output_stride(117)
307 .qmin(std::numeric_limits<uint8_t>::min())
308 .qmax(std::numeric_limits<uint8_t>::max())
309 .iterations(3)
310 .TestF32toQU8();
311 }
312 }
313
TEST(CONVERT_NC_F32_QU8,scale)314 TEST(CONVERT_NC_F32_QU8, scale) {
315 for (float scale : std::vector<float>{{0.1f, 1.0f, 10.0f}}) {
316 for (size_t channels = 1; channels < 100; channels++) {
317 ConvertOperatorTester()
318 .batch_size(3)
319 .channels(channels)
320 .scale(scale)
321 .qmin(std::numeric_limits<uint8_t>::min())
322 .qmax(std::numeric_limits<uint8_t>::max())
323 .iterations(3)
324 .TestF32toQU8();
325 }
326 }
327 }
328
TEST(CONVERT_NC_F32_QU8,output_zero_point)329 TEST(CONVERT_NC_F32_QU8, output_zero_point) {
330 for (int16_t zero_point = std::numeric_limits<uint8_t>::min();
331 zero_point <= std::numeric_limits<uint8_t>::max();
332 zero_point += 51)
333 {
334 for (size_t channels = 1; channels < 100; channels++) {
335 ConvertOperatorTester()
336 .batch_size(3)
337 .channels(channels)
338 .zero_point(zero_point)
339 .qmin(std::numeric_limits<uint8_t>::min())
340 .qmax(std::numeric_limits<uint8_t>::max())
341 .iterations(3)
342 .TestF32toQU8();
343 }
344 }
345 }
346
TEST(CONVERT_NC_F32_QU8,output_min)347 TEST(CONVERT_NC_F32_QU8, output_min) {
348 for (int16_t qmin = std::numeric_limits<uint8_t>::min();
349 qmin < std::numeric_limits<uint8_t>::max();
350 qmin += 51)
351 {
352 for (size_t channels = 1; channels < 100; channels++) {
353 ConvertOperatorTester()
354 .batch_size(3)
355 .channels(channels)
356 .qmin(qmin)
357 .qmax(std::numeric_limits<uint8_t>::max())
358 .iterations(3)
359 .TestF32toQU8();
360 }
361 }
362 }
363
TEST(CONVERT_NC_F32_QU8,output_max)364 TEST(CONVERT_NC_F32_QU8, output_max) {
365 for (int16_t qmax = std::numeric_limits<uint8_t>::min() + 1;
366 qmax <= std::numeric_limits<uint8_t>::max();
367 qmax += 51)
368 {
369 for (size_t channels = 1; channels < 100; channels++) {
370 ConvertOperatorTester()
371 .batch_size(3)
372 .channels(channels)
373 .qmin(std::numeric_limits<uint8_t>::min())
374 .qmax(qmax)
375 .iterations(3)
376 .TestF32toQU8();
377 }
378 }
379 }
380
TEST(CONVERT_NC_QS8_F32,unit_batch)381 TEST(CONVERT_NC_QS8_F32, unit_batch) {
382 for (size_t channels = 1; channels < 100; channels++) {
383 ConvertOperatorTester()
384 .batch_size(1)
385 .channels(channels)
386 .iterations(3)
387 .TestQS8toF32();
388 }
389 }
390
TEST(CONVERT_NC_QS8_F32,small_batch)391 TEST(CONVERT_NC_QS8_F32, small_batch) {
392 for (size_t channels = 1; channels < 100; channels++) {
393 ConvertOperatorTester()
394 .batch_size(3)
395 .channels(channels)
396 .iterations(3)
397 .TestQS8toF32();
398 }
399 }
400
TEST(CONVERT_NC_QS8_F32,small_batch_with_input_stride)401 TEST(CONVERT_NC_QS8_F32, small_batch_with_input_stride) {
402 for (size_t channels = 1; channels < 100; channels += 15) {
403 ConvertOperatorTester()
404 .batch_size(3)
405 .channels(channels)
406 .input_stride(129)
407 .iterations(3)
408 .TestQS8toF32();
409 }
410 }
411
TEST(CONVERT_NC_QS8_F32,small_batch_with_output_stride)412 TEST(CONVERT_NC_QS8_F32, small_batch_with_output_stride) {
413 for (size_t channels = 1; channels < 100; channels += 15) {
414 ConvertOperatorTester()
415 .batch_size(3)
416 .channels(channels)
417 .output_stride(117)
418 .iterations(3)
419 .TestQS8toF32();
420 }
421 }
422
TEST(CONVERT_NC_QS8_F32,small_batch_with_input_and_output_stride)423 TEST(CONVERT_NC_QS8_F32, small_batch_with_input_and_output_stride) {
424 for (size_t channels = 1; channels < 100; channels += 15) {
425 ConvertOperatorTester()
426 .batch_size(3)
427 .channels(channels)
428 .input_stride(129)
429 .output_stride(117)
430 .iterations(3)
431 .TestQS8toF32();
432 }
433 }
434
TEST(CONVERT_NC_QS8_F32,input_scale)435 TEST(CONVERT_NC_QS8_F32, input_scale) {
436 for (float scale : std::vector<float>{{0.1f, 1.0f, 10.0f}}) {
437 for (size_t channels = 1; channels < 100; channels++) {
438 ConvertOperatorTester()
439 .batch_size(3)
440 .channels(channels)
441 .scale(scale)
442 .iterations(3)
443 .TestQS8toF32();
444 }
445 }
446 }
447
TEST(CONVERT_NC_QS8_F32,input_zero_point)448 TEST(CONVERT_NC_QS8_F32, input_zero_point) {
449 for (int16_t zero_point = std::numeric_limits<int8_t>::min();
450 zero_point <= std::numeric_limits<int8_t>::max();
451 zero_point += 51)
452 {
453 for (size_t channels = 1; channels < 100; channels++) {
454 ConvertOperatorTester()
455 .batch_size(3)
456 .channels(channels)
457 .zero_point(zero_point)
458 .iterations(3)
459 .TestQS8toF32();
460 }
461 }
462 }
463
TEST(CONVERT_NC_QU8_F32,unit_batch)464 TEST(CONVERT_NC_QU8_F32, unit_batch) {
465 for (size_t channels = 1; channels < 100; channels++) {
466 ConvertOperatorTester()
467 .batch_size(1)
468 .channels(channels)
469 .iterations(3)
470 .TestQU8toF32();
471 }
472 }
473
TEST(CONVERT_NC_QU8_F32,small_batch)474 TEST(CONVERT_NC_QU8_F32, small_batch) {
475 for (size_t channels = 1; channels < 100; channels++) {
476 ConvertOperatorTester()
477 .batch_size(3)
478 .channels(channels)
479 .iterations(3)
480 .TestQU8toF32();
481 }
482 }
483
TEST(CONVERT_NC_QU8_F32,small_batch_with_input_stride)484 TEST(CONVERT_NC_QU8_F32, small_batch_with_input_stride) {
485 for (size_t channels = 1; channels < 100; channels += 15) {
486 ConvertOperatorTester()
487 .batch_size(3)
488 .channels(channels)
489 .input_stride(129)
490 .iterations(3)
491 .TestQU8toF32();
492 }
493 }
494
TEST(CONVERT_NC_QU8_F32,small_batch_with_output_stride)495 TEST(CONVERT_NC_QU8_F32, small_batch_with_output_stride) {
496 for (size_t channels = 1; channels < 100; channels += 15) {
497 ConvertOperatorTester()
498 .batch_size(3)
499 .channels(channels)
500 .output_stride(117)
501 .iterations(3)
502 .TestQU8toF32();
503 }
504 }
505
TEST(CONVERT_NC_QU8_F32,small_batch_with_input_and_output_stride)506 TEST(CONVERT_NC_QU8_F32, small_batch_with_input_and_output_stride) {
507 for (size_t channels = 1; channels < 100; channels += 15) {
508 ConvertOperatorTester()
509 .batch_size(3)
510 .channels(channels)
511 .input_stride(129)
512 .output_stride(117)
513 .iterations(3)
514 .TestQU8toF32();
515 }
516 }
517
TEST(CONVERT_NC_QU8_F32,input_scale)518 TEST(CONVERT_NC_QU8_F32, input_scale) {
519 for (float scale : std::vector<float>{{0.1f, 1.0f, 10.0f}}) {
520 for (size_t channels = 1; channels < 100; channels++) {
521 ConvertOperatorTester()
522 .batch_size(3)
523 .channels(channels)
524 .scale(scale)
525 .iterations(3)
526 .TestQU8toF32();
527 }
528 }
529 }
530
TEST(CONVERT_NC_QU8_F32,input_zero_point)531 TEST(CONVERT_NC_QU8_F32, input_zero_point) {
532 for (int16_t zero_point = std::numeric_limits<uint8_t>::min();
533 zero_point <= std::numeric_limits<uint8_t>::max();
534 zero_point += 51)
535 {
536 for (size_t channels = 1; channels < 100; channels++) {
537 ConvertOperatorTester()
538 .batch_size(3)
539 .channels(channels)
540 .zero_point(zero_point)
541 .iterations(3)
542 .TestQU8toF32();
543 }
544 }
545 }
546