Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / f7ac72c85c90c61be14fff16c9c2ff638fa32c40 / . / delegate / src / test / ElementwiseBinaryTest.cpp
blob: 448b3e6fd925bbfbe4798b2169f1e013f4679712 [file] [log] [blame]
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]1//
2// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
3// SPDX-License-Identifier: MIT
4//
5
6#include "ElementwiseBinaryTestHelper.hpp"
7
8#include <armnn_delegate.hpp>
9
10#include <flatbuffers/flatbuffers.h>
11#include <tensorflow/lite/interpreter.h>
12#include <tensorflow/lite/kernels/register.h>
13#include <tensorflow/lite/model.h>
14#include <tensorflow/lite/schema/schema_generated.h>
15#include <tensorflow/lite/version.h>
16
17#include <doctest/doctest.h>
18
19namespace armnnDelegate
20{
21
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]22void AddFP32Test(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]23{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]24 std::vector<int32_t> input0Shape { 2, 2, 2, 3 };
25 std::vector<int32_t> input1Shape { 2, 2, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]26 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]27
28 std::vector<float> input0Values =
29 {
30 0.0f, 2.0f, 1.0f,
31 0.2f, 1.0f, 2.0f,
32
33 1.0f, 2.0f, 1.0f,
34 0.2f, 1.0f, 2.0f,
35
36 0.0f, 2.0f, 1.0f,
37 4.2f, 1.0f, 2.0f,
38
39 0.0f, 0.0f, 1.0f,
40 0.2f, 1.0f, 2.0f,
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]41 };
42
43 std::vector<float> input1Values =
44 {
45 1.0f, 2.0f, 1.0f,
46 0.0f, 1.0f, 2.0f,
47
48 1.0f, 2.0f, -2.0f,
49 0.2f, 1.0f, 2.0f,
50
51 0.0f, 2.0f, 1.0f,
52 4.2f, 0.0f, -3.0f,
53
54 0.0f, 0.0f, 1.0f,
55 0.7f, 1.0f, 5.0f,
56 };
57
58 std::vector<float> expectedOutputValues =
59 {
60 1.0f, 4.0f, 2.0f,
61 0.2f, 2.0f, 4.0f,
62
63 2.0f, 4.0f, -1.0f,
64 0.4f, 2.0f, 4.0f,
65
66 0.0f, 4.0f, 2.0f,
67 8.4f, 1.0f, -1.0f,
68
69 0.0f, 0.0f, 2.0f,
70 0.9f, 2.0f, 7.0f,
71 };
72
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]73 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
74 tflite::ActivationFunctionType_NONE,
75 ::tflite::TensorType_FLOAT32,
76 backends,
77 input0Shape,
78 input1Shape,
79 expectedOutputShape,
80 input0Values,
81 input1Values,
82 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]83}
84
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]85void AddBroadcastTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]86{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]87 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
88 std::vector<int32_t> input1Shape { 1, 1, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]89 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]90
91 std::vector<float> input0Values
92 {
93 0.0f,
94 1.0f,
95
96 2.0f,
97 3.0f,
98
99 4.0f,
100 5.0f,
101 };
102 std::vector<float> input1Values
103 {
104 0.5f, 1.5f, 2.5f,
105 3.5f, 4.5f, 5.5f,
106 };
107 // Set output data
108 std::vector<float> expectedOutputValues
109 {
110 0.5f, 1.5f, 2.5f,
111 4.5f, 5.5f, 6.5f,
112
113 2.5f, 3.5f, 4.5f,
114 6.5f, 7.5f, 8.5f,
115
116 4.5f, 5.5f, 6.5f,
117 8.5f, 9.5f, 10.5f,
118 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]119
120 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
121 tflite::ActivationFunctionType_NONE,
122 ::tflite::TensorType_FLOAT32,
123 backends,
124 input0Shape,
125 input1Shape,
126 expectedOutputShape,
127 input0Values,
128 input1Values,
129 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]130}
131
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame^]132void AddConstInputTest(std::vector<armnn::BackendId>& backends)
133{
134 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
135 std::vector<int32_t> input1Shape { 1 };
136 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 1 };
137
138 std::vector<float> input0Values
139 {
140 0.0f,
141 1.0f,
142
143 2.0f,
144 3.0f,
145
146 4.0f,
147 5.0f,
148 };
149 std::vector<float> input1Values
150 {
151 0.5f
152 };
153 // Set output data
154 std::vector<float> expectedOutputValues
155 {
156 0.5f,
157 1.5f,
158
159 2.5f,
160 3.5f,
161
162 4.5f,
163 5.5f,
164 };
165
166 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
167 tflite::ActivationFunctionType_NONE,
168 ::tflite::TensorType_FLOAT32,
169 backends,
170 input0Shape,
171 input1Shape,
172 expectedOutputShape,
173 input0Values,
174 input1Values,
175 expectedOutputValues,
176 1.0f,
177 0,
178 true);
179}
180
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]181void AddActivationTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]182{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]183 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
184 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]185 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]186
187 std::vector<float> input0Values { 4.0f, 0.8f, 0.7f, -0.8f };
188 std::vector<float> input1Values { 0.7f, -1.2f, 0.8f, 0.5f };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]189 std::vector<float> expectedOutputValues { 4.7f, 0.0f, 1.5f, 0.0f };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]190
191 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
192 tflite::ActivationFunctionType_RELU,
193 ::tflite::TensorType_FLOAT32,
194 backends,
195 input0Shape,
196 input1Shape,
197 expectedOutputShape,
198 input0Values,
199 input1Values,
200 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]201}
202
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]203void AddUint8Test(std::vector<armnn::BackendId>& backends)
204{
205 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
206 std::vector<int32_t> input1Shape { 1, 2, 2, 3 };
207 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
208
209 std::vector<uint8_t> input0Values =
210 {
211 63, 35, 77, 70, 56, 112,
212 203, 28, 252, 168, 245, 91
213 };
214
215 std::vector<uint8_t> input1Values =
216 {
217 21, 7, 175, 231, 175, 210,
218 126, 161, 63, 21, 105, 126
219 };
220
221 std::vector<uint8_t> expectedOutputValues =
222 {
223 81, 39, 249, 255, 228, 255,
224 255, 186, 255, 186, 255, 214,
225 };
226
227 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_ADD,
228 tflite::ActivationFunctionType_NONE,
229 ::tflite::TensorType_UINT8,
230 backends,
231 input0Shape,
232 input1Shape,
233 expectedOutputShape,
234 input0Values,
235 input1Values,
236 expectedOutputValues, 7.0f, 3);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]237}
238
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]239void DivFP32Test(std::vector<armnn::BackendId>& backends)
240{
241 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
242 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
243 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
244
245 std::vector<float> input0Values =
246 {
247 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
248 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
249
250 };
251
252 std::vector<float> input1Values =
253 {
254 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
255 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f
256 };
257
258 std::vector<float> expectedOutputValues =
259 {
260 2.f, 2.f, 2.f, 2.f, 1.50f, 1.50f, 1.50f, 1.50f,
261 1.f, 1.f, 1.f, 1.f, 1.25f, 1.25f, 1.25f, 1.25f
262 };
263
264 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
265 tflite::ActivationFunctionType_NONE,
266 ::tflite::TensorType_FLOAT32,
267 backends,
268 input0Shape,
269 input1Shape,
270 expectedOutputShape,
271 input0Values,
272 input1Values,
273 expectedOutputValues);
274}
275
276void DivBroadcastTest(std::vector<armnn::BackendId>& backends)
277{
278 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
279 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
280 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
281
282 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
283 std::vector<float> input1Values = { 2 };
284 std::vector<float> expectedOutputValues = { 1, 2, 3, 4, 5, 6, 7, 8 };
285
286 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
287 tflite::ActivationFunctionType_NONE,
288 ::tflite::TensorType_FLOAT32,
289 backends,
290 input0Shape,
291 input1Shape,
292 expectedOutputShape,
293 input0Values,
294 input1Values,
295 expectedOutputValues);
296}
297
298void DivUint8Test(std::vector<armnn::BackendId>& backends)
299{
300 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
301 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
302 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
303
304 std::vector<uint8_t> input0Values =
305 {
306 2, 2, 2, 2, 3, 3, 3, 3,
307 4, 4, 4, 4, 5, 5, 5, 5
308
309 };
310
311 std::vector<uint8_t> input1Values =
312 {
313 1, 1, 1, 1, 2, 2, 2, 2,
314 4, 4, 4, 4, 4, 4, 4, 4
315 };
316
317 std::vector<uint8_t> expectedOutputValues =
318 {
319 8, 8, 8, 8, 6, 6, 6, 6,
320 4, 4, 4, 4, 5, 5, 5, 5
321 };
322
323 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_DIV,
324 tflite::ActivationFunctionType_NONE,
325 ::tflite::TensorType_UINT8,
326 backends,
327 input0Shape,
328 input1Shape,
329 expectedOutputShape,
330 input0Values,
331 input1Values,
332 expectedOutputValues, 0.25f, 0);
333}
334
335void MaxFP32Test(std::vector<armnn::BackendId>& backends)
336{
337 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
338 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
339 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
340
341 std::vector<float> input0Values =
342 {
343 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
344 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
345
346 };
347
348 std::vector<float> input1Values =
349 {
350 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
351 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
352 };
353
354 std::vector<float> expectedOutputValues =
355 {
356 2.f, 2.f, 5.f, 2.f, 3.f, 3.f, 7.f, 3.f,
357 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
358 };
359
360 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
361 tflite::ActivationFunctionType_NONE,
362 ::tflite::TensorType_FLOAT32,
363 backends,
364 input0Shape,
365 input1Shape,
366 expectedOutputShape,
367 input0Values,
368 input1Values,
369 expectedOutputValues);
370}
371
372void MaxBroadcastTest(std::vector<armnn::BackendId>& backends)
373{
374 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
375 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
376 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
377
378 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
379 std::vector<float> input1Values = { 4.f };
380 std::vector<float> expectedOutputValues = { 4.f, 4.f, 4.f, 4.f, 5.f, 6.f, 7.f, 8.f };
381
382 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
383 tflite::ActivationFunctionType_NONE,
384 ::tflite::TensorType_FLOAT32,
385 backends,
386 input0Shape,
387 input1Shape,
388 expectedOutputShape,
389 input0Values,
390 input1Values,
391 expectedOutputValues);
392}
393
394void MaxUint8Test(std::vector<armnn::BackendId>& backends)
395{
396 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
397 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
398 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
399
400 std::vector<uint8_t> input0Values =
401 {
402 1, 1, 1, 1, 7, 8, 9, 9,
403 3, 3, 3, 3, 4, 4, 4, 4
404
405 };
406
407 std::vector<uint8_t> input1Values =
408 {
409 2, 2, 2, 2, 3, 3, 3, 3,
410 4, 4, 4, 4, 5, 5, 5, 5
411 };
412
413 std::vector<uint8_t> expectedOutputValues =
414 {
415 2, 2, 2, 2, 7, 8, 9, 9,
416 4, 4, 4, 4, 5, 5, 5, 5
417 };
418
419 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MAXIMUM,
420 tflite::ActivationFunctionType_NONE,
421 ::tflite::TensorType_UINT8,
422 backends,
423 input0Shape,
424 input1Shape,
425 expectedOutputShape,
426 input0Values,
427 input1Values,
428 expectedOutputValues, 1.0f, 0);
429}
430
431void MinFP32Test(std::vector<armnn::BackendId>& backends)
432{
433 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
434 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
435 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
436
437 std::vector<float> input0Values =
438 {
439 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
440 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
441
442 };
443
444 std::vector<float> input1Values =
445 {
446 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
447 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f
448 };
449
450 std::vector<float> expectedOutputValues =
451 {
452 1.f, 1.f, 2.f, 1.f, 2.f, 2.f, 3.f, 2.f,
453 1.f, 1.f, 1.f, 1.f, 4.f, 4.f, 4.f, 4.f
454 };
455
456 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
457 tflite::ActivationFunctionType_NONE,
458 ::tflite::TensorType_FLOAT32,
459 backends,
460 input0Shape,
461 input1Shape,
462 expectedOutputShape,
463 input0Values,
464 input1Values,
465 expectedOutputValues);
466}
467
468void MinBroadcastTest(std::vector<armnn::BackendId>& backends)
469{
470 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
471 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
472 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
473
474 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
475
476 std::vector<float> input1Values = { 4.f };
477
478 std::vector<float> expectedOutputValues = { 1.f, 2.f, 3.f, 4.f, 4.f, 4.f, 4.f, 4.f };
479
480 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
481 tflite::ActivationFunctionType_NONE,
482 ::tflite::TensorType_FLOAT32,
483 backends,
484 input0Shape,
485 input1Shape,
486 expectedOutputShape,
487 input0Values,
488 input1Values,
489 expectedOutputValues);
490}
491
492void MinUint8Test(std::vector<armnn::BackendId>& backends)
493{
494 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
495 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
496 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
497
498 std::vector<uint8_t> input0Values =
499 {
500 1, 1, 1, 1, 7, 8, 9, 9,
501 3, 3, 3, 3, 4, 4, 4, 4
502
503 };
504
505 std::vector<uint8_t> input1Values =
506 {
507 2, 2, 2, 2, 3, 3, 3, 3,
508 4, 4, 4, 4, 5, 5, 5, 5
509 };
510
511 std::vector<uint8_t> expectedOutputValues =
512 {
513 1, 1, 1, 1, 3, 3, 3, 3,
514 3, 3, 3, 3, 4, 4, 4, 4
515 };
516
517 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MINIMUM,
518 tflite::ActivationFunctionType_NONE,
519 ::tflite::TensorType_UINT8,
520 backends,
521 input0Shape,
522 input1Shape,
523 expectedOutputShape,
524 input0Values,
525 input1Values,
526 expectedOutputValues, 1.0f, 0);
527}
528
529void MulFP32Test(std::vector<armnn::BackendId>& backends)
530{
531 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
532 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
533 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
534
535 std::vector<float> input0Values =
536 {
537 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
538 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
539
540 };
541
542 std::vector<float> input1Values =
543 {
544 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
545 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
546 };
547
548 std::vector<float> expectedOutputValues =
549 {
550 2.f, 2.f, 2.f, 2.f, 6.f, 6.f, 6.f, 6.f,
551 12.f, 12.f, 12.f, 12.f, 20.f, 20.f, 20.f, 20.f
552 };
553
554 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
555 tflite::ActivationFunctionType_NONE,
556 ::tflite::TensorType_FLOAT32,
557 backends,
558 input0Shape,
559 input1Shape,
560 expectedOutputShape,
561 input0Values,
562 input1Values,
563 expectedOutputValues);
564}
565
566void MulBroadcastTest(std::vector<armnn::BackendId>& backends)
567{
568 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
569 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
570 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
571
572 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
573 std::vector<float> input1Values = { 2 };
574 std::vector<float> expectedOutputValues = { 4, 8, 12, 16, 20, 24, 28, 32 };
575
576 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
577 tflite::ActivationFunctionType_NONE,
578 ::tflite::TensorType_FLOAT32,
579 backends,
580 input0Shape,
581 input1Shape,
582 expectedOutputShape,
583 input0Values,
584 input1Values,
585 expectedOutputValues);
586}
587
588void MulUint8Test(std::vector<armnn::BackendId>& backends)
589{
590 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
591 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
592 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
593
594 std::vector<uint8_t> input0Values =
595 {
596 1, 2, 3, 4, 5, 6,
597 7, 8, 9, 10, 11, 12
598
599 };
600
601 std::vector<uint8_t> input1Values = { 1, 2, 3 };
602
603 std::vector<uint8_t> expectedOutputValues =
604 {
605 1, 4, 9, 4, 10, 18,
606 7, 16, 27, 10, 22, 36
607 };
608
609 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MUL,
610 tflite::ActivationFunctionType_NONE,
611 ::tflite::TensorType_UINT8,
612 backends,
613 input0Shape,
614 input1Shape,
615 expectedOutputShape,
616 input0Values,
617 input1Values,
618 expectedOutputValues, 1.0f, 0);
619}
620
621void MulActivationTest(std::vector<armnn::BackendId>& backends)
622{
623 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
624 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
625 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
626
627 std::vector<float> input0Values { 4.0f, 0.0f, 1.0f, 0.5f };
628 std::vector<float> input1Values { -2.0f, -1.2f, 2.5f, 2.0f };
629 std::vector<float> expectedOutputValues { 0.0f, 0.0f, 2.5f, 1.0f };
630
631 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
632 tflite::ActivationFunctionType_RELU,
633 ::tflite::TensorType_FLOAT32,
634 backends,
635 input0Shape,
636 input1Shape,
637 expectedOutputShape,
638 input0Values,
639 input1Values,
640 expectedOutputValues);
641}
642
643void SubFP32Test(std::vector<armnn::BackendId>& backends)
644{
645 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
646 std::vector<int32_t> input1Shape { 1, 1, 2, 2 };
647 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
648
649 std::vector<float> input0Values = { 1, 3, 3, -7 };
650 std::vector<float> input1Values = { 1, -1, 0, -2 };
651 std::vector<float> expectedOutputValues = { 0, 4, 3, -5 };
652
653 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
654 tflite::ActivationFunctionType_NONE,
655 ::tflite::TensorType_FLOAT32,
656 backends,
657 input0Shape,
658 input1Shape,
659 expectedOutputShape,
660 input0Values,
661 input1Values,
662 expectedOutputValues);
663}
664
665void SubBroadcastTest(std::vector<armnn::BackendId>& backends)
666{
667 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
668 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
669 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
670
671 std::vector<float> input0Values = { 2, 3, 4, 5};
672 std::vector<float> input1Values = { 10 };
673 std::vector<float> expectedOutputValues = { -8, -7, -6, -5 };
674
675 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
676 tflite::ActivationFunctionType_NONE,
677 ::tflite::TensorType_FLOAT32,
678 backends,
679 input0Shape,
680 input1Shape,
681 expectedOutputShape,
682 input0Values,
683 input1Values,
684 expectedOutputValues);
685}
686
687void SubUint8Test(std::vector<armnn::BackendId>& backends)
688{
689 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
690 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
691 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
692
693 std::vector<uint8_t> input0Values = { 10, 12, 14, 16 };
694 std::vector<uint8_t> input1Values = { 2 };
695 std::vector<uint8_t> expectedOutputValues = { 8, 10, 12, 14 };
696
697 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_SUB,
698 tflite::ActivationFunctionType_NONE,
699 ::tflite::TensorType_UINT8,
700 backends,
701 input0Shape,
702 input1Shape,
703 expectedOutputShape,
704 input0Values,
705 input1Values,
706 expectedOutputValues, 1.0f, 0);
707}
708
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]709TEST_SUITE("ElementwiseBinary_GpuAccTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]710{
711
712TEST_CASE ("ADD_FP32_GpuAcc_Test")
713{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]714 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]715 AddFP32Test(backends);
716}
717
718TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
719{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]720 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]721 AddBroadcastTest(backends);
722}
723
724TEST_CASE ("ADD_Activation_GpuAcc_Test")
725{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]726 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]727 AddActivationTest(backends);
728}
729
730TEST_CASE ("ADD_UINT8_GpuAcc_Test")
731{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]732 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]733 AddUint8Test(backends);
734}
735
736TEST_CASE ("DIV_FP32_GpuAcc_Test")
737{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]738 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]739 DivFP32Test(backends);
740}
741
742TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
743{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]744 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]745 DivBroadcastTest(backends);
746}
747
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]748TEST_CASE ("MAX_FP32_GpuAcc_Test")
749{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]750 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]751 MaxFP32Test(backends);
752}
753
754TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
755{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]756 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]757 MaxBroadcastTest(backends);
758}
759
760TEST_CASE ("MAX_UINT8_GpuAcc_Test")
761{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]762 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]763 MaxUint8Test(backends);
764}
765
766TEST_CASE ("MIN_FP32_GpuAcc_Test")
767{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]768 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]769 MinFP32Test(backends);
770}
771
772TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
773{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]774 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]775 MinBroadcastTest(backends);
776}
777
778TEST_CASE ("MIN_UINT8_GpuAcc_Test")
779{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]780 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]781 MinUint8Test(backends);
782}
783
784TEST_CASE ("MUL_FP32_GpuAcc_Test")
785{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]786 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]787 MulFP32Test(backends);
788}
789
790TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
791{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]792 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]793 MulBroadcastTest(backends);
794}
795
796TEST_CASE ("MUL_Activation_GpuAcc_Test")
797{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]798 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]799 MulActivationTest(backends);
800}
801
802TEST_CASE ("MUL_UINT8_GpuAcc_Test")
803{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]804 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]805 MulUint8Test(backends);
806}
807
808TEST_CASE ("SUB_FP32_GpuAcc_Test")
809{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]810 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]811 SubFP32Test(backends);
812}
813
814TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
815{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]816 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]817 SubBroadcastTest(backends);
818}
819
820TEST_CASE ("SUB_UINT8_GpuAcc_Test")
821{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]822 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]823 SubUint8Test(backends);
824}
825
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]826} //TEST_SUITE("ElementwiseBinary_GpuAccTests")
827
828
829
830TEST_SUITE("ElementwiseBinary_CpuAccTests")
831{
832
833TEST_CASE ("ADD_FP32_CpuAcc_Test")
834{
835 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
836 AddFP32Test(backends);
837}
838
839TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
840{
841 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
842 AddBroadcastTest(backends);
843}
844
845TEST_CASE ("ADD_Actiation_CpuAcc_Test")
846{
847 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
848 AddActivationTest(backends);
849}
850
851TEST_CASE ("ADD_UINT8_CpuAcc_Test")
852{
853 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
854 AddUint8Test(backends);
855}
856
857TEST_CASE ("DIV_FP32_CpuAcc_Test")
858{
859 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
860 DivFP32Test(backends);
861}
862
863TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
864{
865 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
866 DivBroadcastTest(backends);
867}
868
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]869TEST_CASE ("MAX_FP32_CpuAcc_Test")
870{
871 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
872 MaxFP32Test(backends);
873}
874
875TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
876{
877 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
878 MaxBroadcastTest(backends);
879}
880
881TEST_CASE ("MAX_UINT8_CpuAcc_Test")
882{
883 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
884 MaxUint8Test(backends);
885}
886
887TEST_CASE ("MIN_FP32_CpuAcc_Test")
888{
889 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
890 MinFP32Test(backends);
891}
892
893TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
894{
895 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
896 MinBroadcastTest(backends);
897}
898
899TEST_CASE ("MIN_UINT8_CpuAcc_Test")
900{
901 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
902 MinUint8Test(backends);
903}
904
905TEST_CASE ("MUL_FP32_CpuAcc_Test")
906{
907 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
908 MulFP32Test(backends);
909}
910
911TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
912{
913 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
914 MulBroadcastTest(backends);
915}
916
917TEST_CASE ("MUL_Actiation_CpuAcc_Test")
918{
919 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
920 MulActivationTest(backends);
921}
922
923TEST_CASE ("MUL_UINT8_CpuAcc_Test")
924{
925 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
926 MulUint8Test(backends);
927}
928
929TEST_CASE ("SUB_FP32_CpuAcc_Test")
930{
931 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
932 SubFP32Test(backends);
933}
934
935TEST_CASE ("SUB_Broadcast_CpuAcc_Test")
936{
937 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
938 SubBroadcastTest(backends);
939}
940
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]941TEST_CASE ("SUB_UINT8_CpuAcc_Test")
942{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]943 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]944 SubUint8Test(backends);
945}
946
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]947} // TEST_SUITE("ElementwiseBinary_CpuAccTests")
948
949
950TEST_SUITE("ElementwiseBinary_CpuRefTests")
951{
952
953TEST_CASE ("ADD_FP32_CpuRef_Test")
954{
955 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
956 AddFP32Test(backends);
957}
958
959TEST_CASE ("ADD_Broadcast_CpuRef_Test")
960{
961 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
962 AddBroadcastTest(backends);
963}
964
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame^]965TEST_CASE ("ADD_Constant_Input_CpuRef_Test")
966{
967 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
968 AddConstInputTest(backends);
969}
970
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]971TEST_CASE ("ADD_Actiation_CpuRef_Test")
972{
973 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
974 AddActivationTest(backends);
975}
976
977TEST_CASE ("ADD_UINT8_CpuRef_Test")
978{
979 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
980 AddUint8Test(backends);
981}
982
983TEST_CASE ("DIV_FP32_CpuRef_Test")
984{
985 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
986 DivFP32Test(backends);
987}
988
989TEST_CASE ("DIV_Broadcast_CpuRef_Test")
990{
991 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
992 DivBroadcastTest(backends);
993}
994
995TEST_CASE ("DIV_UINT8_CpuRef_Test")
996{
997 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
998 DivUint8Test(backends);
999}
1000
1001TEST_CASE ("MAX_FP32_CpuRef_Test")
1002{
1003 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1004 MaxFP32Test(backends);
1005}
1006
1007TEST_CASE ("MAX_Broadcast_CpuRef_Test")
1008{
1009 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1010 MaxBroadcastTest(backends);
1011}
1012
1013TEST_CASE ("MAX_UINT8_CpuRef_Test")
1014{
1015 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1016 MaxUint8Test(backends);
1017}
1018
1019TEST_CASE ("MIN_FP32_CpuRef_Test")
1020{
1021 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1022 MinFP32Test(backends);
1023}
1024
1025TEST_CASE ("MIN_Broadcast_CpuRef_Test")
1026{
1027 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1028 MinBroadcastTest(backends);
1029}
1030
1031TEST_CASE ("MIN_UINT8_CpuRef_Test")
1032{
1033 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1034 MinUint8Test(backends);
1035}
1036
1037TEST_CASE ("MUL_FP32_CpuRef_Test")
1038{
1039 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1040 MulFP32Test(backends);
1041}
1042
1043TEST_CASE ("MUL_Broadcast_CpuRef_Test")
1044{
1045 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1046 MulBroadcastTest(backends);
1047}
1048
1049TEST_CASE ("MUL_Actiation_CpuRef_Test")
1050{
1051 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1052 MulActivationTest(backends);
1053}
1054
1055TEST_CASE ("MUL_UINT8_CpuRef_Test")
1056{
1057 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1058 MulUint8Test(backends);
1059}
1060
1061TEST_CASE ("SUB_FP32_CpuRef_Test")
1062{
1063 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1064 SubFP32Test(backends);
1065}
1066
1067TEST_CASE ("SUB_Broadcast_CpuRef_Test")
1068{
1069 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1070 SubBroadcastTest(backends);
1071}
1072
1073TEST_CASE ("SUB_UINT8_CpuRef_Test")
1074{
1075 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1076 SubUint8Test(backends);
1077}
1078
1079} // TEST_SUITE("ElementwiseBinary_CpuRefTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]1080
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]1081} // namespace armnnDelegate