Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 58f8ecdbcc7630c56935d1c9640d4eb12daa6bfd / . / delegate / src / test / ElementwiseBinaryTest.cpp
blob: 2a8c91b2ef1f065ad02c298919d4e49aac834678 [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
660TEST_SUITE("ElementwiseBinaryTest")
661{
662
663TEST_CASE ("ADD_FP32_GpuAcc_Test")
664{
665 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
666 armnn::Compute::CpuRef };
667 AddFP32Test(backends);
668}
669
670TEST_CASE ("ADD_FP32_CpuAcc_Test")
671{
672 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
673 armnn::Compute::CpuRef };
674 AddFP32Test(backends);
675}
676
677TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
678{
679 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
680 armnn::Compute::CpuRef };
681 AddBroadcastTest(backends);
682}
683
684TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
685{
686 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
687 armnn::Compute::CpuRef };
688 AddBroadcastTest(backends);
689}
690
691TEST_CASE ("ADD_Activation_GpuAcc_Test")
692{
693 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
694 armnn::Compute::CpuRef };
695 AddActivationTest(backends);
696}
697
698TEST_CASE ("ADD_Actiation_CpuAcc_Test")
699{
700 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
701 armnn::Compute::CpuRef };
702 AddActivationTest(backends);
703}
704
705TEST_CASE ("ADD_UINT8_GpuAcc_Test")
706{
707 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
708 armnn::Compute::CpuRef };
709 AddUint8Test(backends);
710}
711
712TEST_CASE ("ADD_UINT8_CpuAcc_Test")
713{
714 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
715 armnn::Compute::CpuRef };
716 AddUint8Test(backends);
717}
718
719TEST_CASE ("DIV_FP32_GpuAcc_Test")
720{
721 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
722 armnn::Compute::CpuRef };
723 DivFP32Test(backends);
724}
725
726TEST_CASE ("DIV_FP32_CpuAcc_Test")
727{
728 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
729 armnn::Compute::CpuRef };
730 DivFP32Test(backends);
731}
732
733TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
734{
735 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
736 armnn::Compute::CpuRef };
737 DivBroadcastTest(backends);
738}
739
740TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
741{
742 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
743 armnn::Compute::CpuRef };
744 DivBroadcastTest(backends);
745}
746
747TEST_CASE ("DIV_UINT8_GpuAcc_Test")
748{
749 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
750 armnn::Compute::CpuRef };
751 DivUint8Test(backends);
752}
753
754TEST_CASE ("DIV_UINT8_CpuAcc_Test")
755{
756 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
757 armnn::Compute::CpuRef };
758 DivUint8Test(backends);
759}
760
761TEST_CASE ("MAX_FP32_GpuAcc_Test")
762{
763 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
764 armnn::Compute::CpuRef };
765 MaxFP32Test(backends);
766}
767
768TEST_CASE ("MAX_FP32_CpuAcc_Test")
769{
770 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
771 armnn::Compute::CpuRef };
772 MaxFP32Test(backends);
773}
774
775TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
776{
777 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
778 armnn::Compute::CpuRef };
779 MaxBroadcastTest(backends);
780}
781
782TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
783{
784 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
785 armnn::Compute::CpuRef };
786 MaxBroadcastTest(backends);
787}
788
789TEST_CASE ("MAX_UINT8_GpuAcc_Test")
790{
791 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
792 armnn::Compute::CpuRef };
793 MaxUint8Test(backends);
794}
795
796TEST_CASE ("MAX_UINT8_CpuAcc_Test")
797{
798 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
799 armnn::Compute::CpuRef };
800 MaxUint8Test(backends);
801}
802
803TEST_CASE ("MIN_FP32_GpuAcc_Test")
804{
805 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
806 armnn::Compute::CpuRef };
807 MinFP32Test(backends);
808}
809
810TEST_CASE ("MIN_FP32_CpuAcc_Test")
811{
812 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
813 armnn::Compute::CpuRef };
814 MinFP32Test(backends);
815}
816
817TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
818{
819 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
820 armnn::Compute::CpuRef };
821 MinBroadcastTest(backends);
822}
823
824TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
825{
826 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
827 armnn::Compute::CpuRef };
828 MinBroadcastTest(backends);
829}
830
831TEST_CASE ("MIN_UINT8_GpuAcc_Test")
832{
833 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
834 armnn::Compute::CpuRef };
835 MinUint8Test(backends);
836}
837
838TEST_CASE ("MIN_UINT8_CpuAcc_Test")
839{
840 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
841 armnn::Compute::CpuRef };
842 MinUint8Test(backends);
843}
844
845TEST_CASE ("MUL_FP32_GpuAcc_Test")
846{
847 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
848 armnn::Compute::CpuRef };
849 MulFP32Test(backends);
850}
851
852TEST_CASE ("MUL_FP32_CpuAcc_Test")
853{
854 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
855 armnn::Compute::CpuRef };
856 MulFP32Test(backends);
857}
858
859TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
860{
861 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
862 armnn::Compute::CpuRef };
863 MulBroadcastTest(backends);
864}
865
866TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
867{
868 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
869 armnn::Compute::CpuRef };
870 MulBroadcastTest(backends);
871}
872
873TEST_CASE ("MUL_Activation_GpuAcc_Test")
874{
875 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
876 armnn::Compute::CpuRef };
877 MulActivationTest(backends);
878}
879
880TEST_CASE ("MUL_Actiation_CpuAcc_Test")
881{
882 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
883 armnn::Compute::CpuRef };
884 MulActivationTest(backends);
885}
886
887TEST_CASE ("MUL_UINT8_GpuAcc_Test")
888{
889 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
890 armnn::Compute::CpuRef };
891 MulUint8Test(backends);
892}
893
894TEST_CASE ("MUL_UINT8_CpuAcc_Test")
895{
896 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
897 armnn::Compute::CpuRef };
898 MulUint8Test(backends);
899}
900
901TEST_CASE ("SUB_FP32_GpuAcc_Test")
902{
903 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
904 armnn::Compute::CpuRef };
905 SubFP32Test(backends);
906}
907
908TEST_CASE ("SUB_FP32_CpuAcc_Test")
909{
910 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
911 armnn::Compute::CpuRef };
912 SubFP32Test(backends);
913}
914
915TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
916{
917 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
918 armnn::Compute::CpuRef };
919 SubBroadcastTest(backends);
920}
921
922TEST_CASE ("SUB_Broadcast_CpuAcc_Test")
923{
924 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
925 armnn::Compute::CpuRef };
926 SubBroadcastTest(backends);
927}
928
929TEST_CASE ("SUB_UINT8_GpuAcc_Test")
930{
931 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
932 armnn::Compute::CpuRef };
933 SubUint8Test(backends);
934}
935
936TEST_CASE ("SUB_UINT8_CpuAcc_Test")
937{
938 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
939 armnn::Compute::CpuRef };
940 SubUint8Test(backends);
941}
942
943} // End of TEST_SUITE("ElementwiseBinaryTest")
944
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]945} // namespace armnnDelegate