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