1 //
2 // Copyright © 2020,2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5
6 #include "ControlTestHelper.hpp"
7
8 #include <armnn_delegate.hpp>
9
10 #include <flatbuffers/flatbuffers.h>
11 #include <schema_generated.h>
12
13 #include <doctest/doctest.h>
14
15 namespace armnnDelegate
16 {
17
18 // CONCATENATION Operator
ConcatUint8TwoInputsTest(std::vector<armnn::BackendId> & backends)19 void ConcatUint8TwoInputsTest(std::vector<armnn::BackendId>& backends)
20 {
21 std::vector<int32_t> inputShape { 2, 2 };
22 std::vector<int32_t> expectedOutputShape { 4, 2 };
23
24 // Set input and output data
25 std::vector<std::vector<uint8_t>> inputValues;
26 std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 }; // Lower bounds
27 std::vector<uint8_t> inputValue2 { 252, 253, 254, 255 }; // Upper bounds
28 inputValues.push_back(inputValue1);
29 inputValues.push_back(inputValue2);
30
31 std::vector<uint8_t> expectedOutputValues { 0, 1, 2, 3, 252, 253, 254, 255 };
32
33 ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION,
34 ::tflite::TensorType_UINT8,
35 backends,
36 inputShape,
37 expectedOutputShape,
38 inputValues,
39 expectedOutputValues);
40 }
41
ConcatInt16TwoInputsTest(std::vector<armnn::BackendId> & backends)42 void ConcatInt16TwoInputsTest(std::vector<armnn::BackendId>& backends)
43 {
44 std::vector<int32_t> inputShape { 2, 2 };
45 std::vector<int32_t> expectedOutputShape { 4, 2 };
46
47 std::vector<std::vector<int16_t>> inputValues;
48 std::vector<int16_t> inputValue1 { -32768, -16384, -1, 0 };
49 std::vector<int16_t> inputValue2 { 1, 2, 16384, 32767 };
50 inputValues.push_back(inputValue1);
51 inputValues.push_back(inputValue2);
52
53 std::vector<int16_t> expectedOutputValues { -32768, -16384, -1, 0, 1, 2, 16384, 32767};
54
55 ConcatenationTest<int16_t>(tflite::BuiltinOperator_CONCATENATION,
56 ::tflite::TensorType_INT16,
57 backends,
58 inputShape,
59 expectedOutputShape,
60 inputValues,
61 expectedOutputValues);
62 }
63
ConcatFloat32TwoInputsTest(std::vector<armnn::BackendId> & backends)64 void ConcatFloat32TwoInputsTest(std::vector<armnn::BackendId>& backends)
65 {
66 std::vector<int32_t> inputShape { 2, 2 };
67 std::vector<int32_t> expectedOutputShape { 4, 2 };
68
69 std::vector<std::vector<float>> inputValues;
70 std::vector<float> inputValue1 { -127.f, -126.f, -1.f, 0.f };
71 std::vector<float> inputValue2 { 1.f, 2.f, 126.f, 127.f };
72 inputValues.push_back(inputValue1);
73 inputValues.push_back(inputValue2);
74
75 std::vector<float> expectedOutputValues { -127.f, -126.f, -1.f, 0.f, 1.f, 2.f, 126.f, 127.f };
76
77 ConcatenationTest<float>(tflite::BuiltinOperator_CONCATENATION,
78 ::tflite::TensorType_FLOAT32,
79 backends,
80 inputShape,
81 expectedOutputShape,
82 inputValues,
83 expectedOutputValues);
84 }
85
ConcatThreeInputsTest(std::vector<armnn::BackendId> & backends)86 void ConcatThreeInputsTest(std::vector<armnn::BackendId>& backends)
87 {
88 std::vector<int32_t> inputShape { 2, 2 };
89 std::vector<int32_t> expectedOutputShape { 6, 2 };
90
91 std::vector<std::vector<uint8_t>> inputValues;
92 std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 };
93 std::vector<uint8_t> inputValue2 { 125, 126, 127, 128 };
94 std::vector<uint8_t> inputValue3 { 252, 253, 254, 255 };
95 inputValues.push_back(inputValue1);
96 inputValues.push_back(inputValue2);
97 inputValues.push_back(inputValue3);
98
99 std::vector<uint8_t> expectedOutputValues { 0, 1, 2, 3, 125, 126, 127, 128, 252, 253, 254, 255 };
100
101 ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION,
102 ::tflite::TensorType_UINT8,
103 backends,
104 inputShape,
105 expectedOutputShape,
106 inputValues,
107 expectedOutputValues);
108 }
109
ConcatAxisTest(std::vector<armnn::BackendId> & backends)110 void ConcatAxisTest(std::vector<armnn::BackendId>& backends)
111 {
112 std::vector<int32_t> inputShape { 1, 2, 2 };
113 std::vector<int32_t> expectedOutputShape { 1, 2, 4 };
114
115 std::vector<std::vector<uint8_t>> inputValues;
116 std::vector<uint8_t> inputValue1 { 0, 1, 2, 3 };
117 std::vector<uint8_t> inputValue3 { 252, 253, 254, 255 };
118 inputValues.push_back(inputValue1);
119 inputValues.push_back(inputValue3);
120
121 std::vector<uint8_t> expectedOutputValues { 0, 1, 252, 253, 2, 3, 254, 255 };
122
123 ConcatenationTest<uint8_t>(tflite::BuiltinOperator_CONCATENATION,
124 ::tflite::TensorType_UINT8,
125 backends,
126 inputShape,
127 expectedOutputShape,
128 inputValues,
129 expectedOutputValues,
130 2);
131 }
132
133 // MEAN Operator
MeanUint8KeepDimsTest(std::vector<armnn::BackendId> & backends)134 void MeanUint8KeepDimsTest(std::vector<armnn::BackendId>& backends)
135 {
136 std::vector<int32_t> input0Shape { 1, 3 };
137 std::vector<int32_t> input1Shape { 1 };
138 std::vector<int32_t> expectedOutputShape { 1, 1 };
139
140 std::vector<uint8_t> input0Values { 5, 10, 15 }; // Inputs
141 std::vector<int32_t> input1Values { 1 }; // Axis
142
143 std::vector<uint8_t> expectedOutputValues { 10 };
144
145 MeanTest<uint8_t>(tflite::BuiltinOperator_MEAN,
146 ::tflite::TensorType_UINT8,
147 backends,
148 input0Shape,
149 input1Shape,
150 expectedOutputShape,
151 input0Values,
152 input1Values,
153 expectedOutputValues,
154 true);
155 }
156
MeanUint8Test(std::vector<armnn::BackendId> & backends)157 void MeanUint8Test(std::vector<armnn::BackendId>& backends)
158 {
159 std::vector<int32_t> input0Shape { 1, 2, 2 };
160 std::vector<int32_t> input1Shape { 1 };
161 std::vector<int32_t> expectedOutputShape { 2, 2 };
162
163 std::vector<uint8_t> input0Values { 5, 10, 15, 20 }; // Inputs
164 std::vector<int32_t> input1Values { 0 }; // Axis
165
166 std::vector<uint8_t> expectedOutputValues { 5, 10, 15, 20 };
167
168 MeanTest<uint8_t>(tflite::BuiltinOperator_MEAN,
169 ::tflite::TensorType_UINT8,
170 backends,
171 input0Shape,
172 input1Shape,
173 expectedOutputShape,
174 input0Values,
175 input1Values,
176 expectedOutputValues,
177 false);
178 }
179
MeanFp32KeepDimsTest(std::vector<armnn::BackendId> & backends)180 void MeanFp32KeepDimsTest(std::vector<armnn::BackendId>& backends)
181 {
182 std::vector<int32_t> input0Shape { 1, 2, 2 };
183 std::vector<int32_t> input1Shape { 1 };
184 std::vector<int32_t> expectedOutputShape { 1, 1, 2 };
185
186 std::vector<float> input0Values { 1.0f, 1.5f, 2.0f, 2.5f }; // Inputs
187 std::vector<int32_t> input1Values { 1 }; // Axis
188
189 std::vector<float> expectedOutputValues { 1.5f, 2.0f };
190
191 MeanTest<float>(tflite::BuiltinOperator_MEAN,
192 ::tflite::TensorType_FLOAT32,
193 backends,
194 input0Shape,
195 input1Shape,
196 expectedOutputShape,
197 input0Values,
198 input1Values,
199 expectedOutputValues,
200 true);
201 }
202
MeanFp32Test(std::vector<armnn::BackendId> & backends)203 void MeanFp32Test(std::vector<armnn::BackendId>& backends)
204 {
205 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
206 std::vector<int32_t> input1Shape { 1 };
207 std::vector<int32_t> expectedOutputShape { 1, 2, 1 };
208
209 std::vector<float> input0Values { 1.0f, 1.5f, 2.0f, 2.5f }; // Inputs
210 std::vector<int32_t> input1Values { 2 }; // Axis
211
212 std::vector<float> expectedOutputValues { 1.25f, 2.25f };
213
214 MeanTest<float>(tflite::BuiltinOperator_MEAN,
215 ::tflite::TensorType_FLOAT32,
216 backends,
217 input0Shape,
218 input1Shape,
219 expectedOutputShape,
220 input0Values,
221 input1Values,
222 expectedOutputValues,
223 false);
224 }
225
226 // CONCATENATION Tests.
227 TEST_SUITE("Concatenation_CpuAccTests")
228 {
229
230 TEST_CASE ("Concatenation_Uint8_CpuAcc_Test")
231 {
232 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
233 ConcatUint8TwoInputsTest(backends);
234 }
235
236 TEST_CASE ("Concatenation_Int16_CpuAcc_Test")
237 {
238 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
239 ConcatInt16TwoInputsTest(backends);
240 }
241
242 TEST_CASE ("Concatenation_Float32_CpuAcc_Test")
243 {
244 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
245 ConcatFloat32TwoInputsTest(backends);
246 }
247
248 TEST_CASE ("Concatenation_Three_Inputs_CpuAcc_Test")
249 {
250 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
251 ConcatThreeInputsTest(backends);
252 }
253
254 TEST_CASE ("Concatenation_Axis_CpuAcc_Test")
255 {
256 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
257 ConcatAxisTest(backends);
258 }
259
260 }
261
262 TEST_SUITE("Concatenation_GpuAccTests")
263 {
264
265 TEST_CASE ("Concatenation_Uint8_GpuAcc_Test")
266 {
267 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
268 ConcatUint8TwoInputsTest(backends);
269 }
270
271 TEST_CASE ("Concatenation_Int16_GpuAcc_Test")
272 {
273 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
274 ConcatInt16TwoInputsTest(backends);
275 }
276
277 TEST_CASE ("Concatenation_Float32_GpuAcc_Test")
278 {
279 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
280 ConcatFloat32TwoInputsTest(backends);
281 }
282
283 TEST_CASE ("Concatenation_Three_Inputs_GpuAcc_Test")
284 {
285 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
286 ConcatThreeInputsTest(backends);
287 }
288
289 TEST_CASE ("Concatenation_Axis_GpuAcc_Test")
290 {
291 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
292 ConcatAxisTest(backends);
293 }
294
295 }
296
297 TEST_SUITE("Concatenation_CpuRefTests")
298 {
299
300 TEST_CASE ("Concatenation_Uint8_CpuRef_Test")
301 {
302 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
303 ConcatUint8TwoInputsTest(backends);
304 }
305
306 TEST_CASE ("Concatenation_Int16_CpuRef_Test")
307 {
308 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
309 ConcatInt16TwoInputsTest(backends);
310 }
311
312 TEST_CASE ("Concatenation_Float32_CpuRef_Test")
313 {
314 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
315 ConcatFloat32TwoInputsTest(backends);
316 }
317
318 TEST_CASE ("Concatenation_Three_Inputs_CpuRef_Test")
319 {
320 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
321 ConcatThreeInputsTest(backends);
322 }
323
324 TEST_CASE ("Concatenation_Axis_CpuRef_Test")
325 {
326 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
327 ConcatAxisTest(backends);
328 }
329
330 }
331
332 // MEAN Tests
333 TEST_SUITE("Mean_CpuAccTests")
334 {
335
336 TEST_CASE ("Mean_Uint8_KeepDims_CpuAcc_Test")
337 {
338 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
339 MeanUint8KeepDimsTest(backends);
340 }
341
342 TEST_CASE ("Mean_Uint8_CpuAcc_Test")
343 {
344 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
345 MeanUint8Test(backends);
346 }
347
348 TEST_CASE ("Mean_Fp32_KeepDims_CpuAcc_Test")
349 {
350 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
351 MeanFp32KeepDimsTest(backends);
352 }
353
354 TEST_CASE ("Mean_Fp32_CpuAcc_Test")
355 {
356 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuAcc};
357 MeanFp32Test(backends);
358 }
359
360 }
361
362 TEST_SUITE("Mean_GpuAccTests")
363 {
364
365 TEST_CASE ("Mean_Uint8_KeepDims_GpuAcc_Test")
366 {
367 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
368 MeanUint8KeepDimsTest(backends);
369 }
370
371 TEST_CASE ("Mean_Uint8_GpuAcc_Test")
372 {
373 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
374 MeanUint8Test(backends);
375 }
376
377 TEST_CASE ("Mean_Fp32_KeepDims_GpuAcc_Test")
378 {
379 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
380 MeanFp32KeepDimsTest(backends);
381 }
382
383 TEST_CASE ("Mean_Fp32_GpuAcc_Test")
384 {
385 std::vector<armnn::BackendId> backends = {armnn::Compute::GpuAcc};
386 MeanFp32Test(backends);
387 }
388
389 }
390
391 TEST_SUITE("Mean_CpuRefTests")
392 {
393
394 TEST_CASE ("Mean_Uint8_KeepDims_CpuRef_Test")
395 {
396 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
397 MeanUint8KeepDimsTest(backends);
398 }
399
400 TEST_CASE ("Mean_Uint8_CpuRef_Test")
401 {
402 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
403 MeanUint8Test(backends);
404 }
405
406 TEST_CASE ("Mean_Fp32_KeepDims_CpuRef_Test")
407 {
408 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
409 MeanFp32KeepDimsTest(backends);
410 }
411
412 TEST_CASE ("Mean_Fp32_CpuRef_Test")
413 {
414 std::vector<armnn::BackendId> backends = {armnn::Compute::CpuRef};
415 MeanFp32Test(backends);
416 }
417
418 }
419
420 } // namespace armnnDelegate