2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
5 #include "LayerTests.hpp"
6 #include "WorkloadTestUtils.hpp"
7 #include "TensorUtils.hpp"
8 #include <ResolveType.hpp>
10 #include "test/TensorHelpers.hpp"
11 #include "TensorCopyUtils.hpp"
12 #include "Permute.hpp"
14 #include <boost/test/unit_test.hpp>
15 #include <boost/assert.hpp>
17 #include <armnn/LayerSupport.hpp>
19 #include <backendsCommon/CpuTensorHandle.hpp>
20 #include <backendsCommon/IBackendInternal.hpp>
21 #include <backendsCommon/WorkloadFactory.hpp>
23 #include <reference/workloads/RefWorkloads.hpp>
26 #include <boost/cast.hpp>
28 #include "WorkloadTestUtils.hpp"
29 #include "Conv2dTestImpl.hpp"
30 #include "BatchNormTestImpl.hpp"
31 #include "ActivationTestImpl.hpp"
32 #include "Pooling2dTestImpl.hpp"
33 #include "FullyConnectedTestImpl.hpp"
34 #include "GatherTestImpl.hpp"
35 #include "SpaceToBatchNdTestImpl.hpp"
36 #include "SpaceToDepthTestImpl.hpp"
37 #include "SplitterTestImpl.hpp"
38 #include "SoftmaxTestImpl.hpp"
39 #include "StridedSliceTestImpl.hpp"
40 #include "NormTestImpl.hpp"
41 #include "LstmTestImpl.hpp"
42 #include "ConvertFp16ToFp32TestImpl.hpp"
43 #include "ConvertFp32ToFp16TestImpl.hpp"
44 #include "DebugTestImpl.hpp"
45 #include "DequantizeTestImpl.hpp"
46 #include "QuantizeTestImpl.hpp"
47 #include "TransposeConvolution2dTestImpl.hpp"
49 // 3-channel 16x8 image used as common input data for a number of Conv2d tests.
50 static std::vector<float> ConvInput3x8x16({
51 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
52 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
53 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
54 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
55 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
56 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
57 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
58 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
59 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
60 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
62 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
64 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
66 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
67 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
69 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
70 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
71 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
72 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
74 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
77 // 2-channel bias used by a number of Conv2d tests.
78 static std::vector<float> Bias2({0, 2});
80 struct Simple3dSoftmaxOutputData
82 const std::vector<float> outputData =
84 0.0964599f, 0.26220518f, 0.0964599f, 0.0964599f,
85 0.15903549f, 0.0964599f, 0.0964599f, 0.0964599f
88 const armnn::TensorShape inputShape{ 1, 8, 1 };
90 const std::vector<float> inputData =
97 struct Simple4dSoftmaxData
99 const armnn::TensorShape inputShape{ 1, 8, 1, 1 };
101 const std::vector<float> outputData = { 0.0964599f, 0.26220518f, 0.0964599f, 0.0964599f,
102 0.15903549f, 0.0964599f, 0.0964599f, 0.0964599f };
103 const std::vector<float> inputData =
110 // Helper function that returns either Bias2 or an empty vector depending on whether bias is enabled.
111 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
112 boost::multi_array<T, 1> GetBias2(bool biasEnabled, float qScale)
116 armnn::TensorInfo biasDesc({static_cast<unsigned int>(Bias2.size())}, ArmnnType);
117 boost::multi_array<T, 1> bias = MakeTensor<T, 1>(biasDesc, QuantizedVector<T>(qScale, 0.0f, Bias2));
122 return boost::multi_array<T, 1>();
126 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
127 LayerTestResult<T, 4> SimpleConvolution2d3x5TestCommon(
128 armnn::IWorkloadFactory& workloadFactory,
129 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
133 const armnn::DataLayout layout)
135 // Use common single-batch 3-channel 16x8 image.
136 armnn::TensorInfo inputDesc({1, 3, 8, 16}, ArmnnType);
137 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc, QuantizedVector<T>(qScale, qOffset, ConvInput3x8x16));
139 // Use a 2-element batch with 3-channel 3x5 kernels.
140 armnn::TensorInfo kernelDesc({2, 3, 5, 3}, ArmnnType);
141 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc, std::vector<T>(
142 QuantizedVector<T>(qScale, qOffset, {
181 // Expected output is 2 batch elements of a 1-channel 14x4 image.
182 armnn::TensorInfo outputDesc({1, 2, 4, 14}, ArmnnType);
183 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, std::vector<T>(
184 QuantizedVector<T>(qScale, qOffset, {
185 -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24,
186 -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25,
187 -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f,
188 -23.5f, -23.5f, -23.5f,
189 -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f, -23.5f,
190 -23.5f, -23.5f, -23.5f,
192 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
193 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
194 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
195 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
198 return SimpleConvolution2dTestImpl<ArmnnType, ArmnnBType>(
203 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
210 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
211 typename T = armnn::ResolveType<ArmnnType>>
212 LayerTestResult<T, 4> SimpleConvolution2d3x3TestCommon(
213 armnn::IWorkloadFactory& workloadFactory,
214 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
218 const armnn::DataLayout layout)
220 // Use a 3x3 kernel, which exercises ArmCompute's direct convolution path.
222 // Use common single-batch 3-channel 16x8 image.
223 armnn::TensorInfo inputDesc({1, 3, 8, 16}, ArmnnType);
224 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc, QuantizedVector<T>(qScale, qOffset, ConvInput3x8x16));
226 // Use a 2-element batch of 3-channel 3x3 kernels.
227 armnn::TensorInfo kernelDesc({2, 3, 3, 3}, ArmnnType);
228 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc, std::vector<T>(
229 QuantizedVector<T>(qScale, qOffset, {
256 // Expected output is 1 batch of a 2-channel 14x6 image.
257 armnn::TensorInfo outputDesc({1, 2, 6, 14}, ArmnnType);
258 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, std::vector<T>(
259 QuantizedVector<T>(qScale, qOffset, {
260 -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15,
261 -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16,
262 -14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,
263 -14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,
264 -14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,
265 -14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,-14.5f,
267 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
268 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
270 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
271 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
272 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
275 return SimpleConvolution2dTestImpl<ArmnnType, ArmnnBType>(
280 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
287 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
288 LayerTestResult<T, 4> SimpleConvolution2d3x3NhwcTestCommon(
289 armnn::IWorkloadFactory& workloadFactory,
290 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
294 armnn::DataLayout dataLayout)
296 // Use common single-batch 5x5 image.
298 armnn::TensorInfo inputDesc({1, 3, 4, 1}, ArmnnType);
299 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc,
307 // Use a 2-element batch of 3-channel 3x3 kernels.
308 armnn::TensorInfo kernelDesc({1, 3, 3, 1}, ArmnnType);
309 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc, {
315 // Expected output is 1 batch of a 5x5 image.
316 armnn::TensorInfo outputDesc({1, 3, 4, 1}, ArmnnType);
318 const std::vector<float> outputData =
325 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, outputData);
327 return SimpleConvolution2dNhwcTestImpl<ArmnnType, ArmnnType>(
332 boost::multi_array<T, 1>(),
339 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
340 LayerTestResult<T, 4> SimpleConvolution2d3x3Stride2x2TestCommon(
341 armnn::IWorkloadFactory& workloadFactory,
342 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
346 const armnn::DataLayout& dataLayout)
348 // Input is a single-batch, 1 channel, 5x5 image.
349 armnn::TensorInfo inputDesc({1, 5, 5, 1}, ArmnnType);
350 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc,
360 armnn::TensorInfo kernelDesc({1, 3, 3, 1}, ArmnnType);
361 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc,
368 // Expected output is a single-batch, 1 channel, 3x3 image.
369 armnn::TensorInfo outputDesc({1, 3, 3, 1}, ArmnnType);
371 const std::vector<T> outputData =
378 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, outputData);
380 uint32_t padLeft = 1;
382 uint32_t padRight = 1;
383 uint32_t padBottom = 1;
384 uint32_t strideX = 2;
385 uint32_t strideY = 2;
387 return SimpleConvolution2dNhwcTestImpl<ArmnnType, ArmnnType>(
392 boost::multi_array<T, 1>(),
405 LayerTestResult<float, 4> SimpleConvolution2d3x5Test(
406 armnn::IWorkloadFactory& workloadFactory,
407 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
409 const armnn::DataLayout layout)
411 return SimpleConvolution2d3x5TestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
412 workloadFactory, memoryManager, 0.f, 0, biasEnabled, layout);
415 LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(
416 armnn::IWorkloadFactory& workloadFactory,
417 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
419 const armnn::DataLayout layout)
421 return SimpleConvolution2d3x5TestCommon<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
422 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
425 LayerTestResult<float, 4> SimpleConvolution2d3x3Test(
426 armnn::IWorkloadFactory& workloadFactory,
427 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
429 const armnn::DataLayout layout)
431 return SimpleConvolution2d3x3TestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
432 workloadFactory, memoryManager, 0.f, 0, biasEnabled, layout);
435 LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(
436 armnn::IWorkloadFactory& workloadFactory,
437 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
440 return SimpleConvolution2d3x3NhwcTestCommon<armnn::DataType::Float32>(
446 armnn::DataLayout::NHWC);
449 LayerTestResult<float, 4> SimpleConvolution2d3x3Stride2x2Test(
450 armnn::IWorkloadFactory& workloadFactory,
451 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
453 const armnn::DataLayout layout)
455 return SimpleConvolution2d3x3Stride2x2TestCommon<armnn::DataType::Float32>(
464 LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(
465 armnn::IWorkloadFactory& workloadFactory,
466 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
468 const armnn::DataLayout layout)
470 return SimpleConvolution2d3x3TestCommon<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
471 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
474 LayerTestResult<int16_t, 4> SimpleConvolution2d3x5QSymm16Test(
475 armnn::IWorkloadFactory& workloadFactory,
476 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
478 const armnn::DataLayout layout)
480 return SimpleConvolution2d3x5TestCommon<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
481 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
484 LayerTestResult<int16_t, 4> SimpleConvolution2d3x3QSymm16Test(
485 armnn::IWorkloadFactory& workloadFactory,
486 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
488 const armnn::DataLayout layout)
490 return SimpleConvolution2d3x3TestCommon<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
491 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
494 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
495 typename T = armnn::ResolveType<ArmnnType>>
496 LayerTestResult<T, 4> Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTestCommon(
497 armnn::IWorkloadFactory& workloadFactory,
498 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
499 const armnn::DataLayout layout,
503 // Use a single-batch 1-channel 3x3 image as input.
504 armnn::TensorInfo inputDesc({1, 1, 3, 3}, ArmnnType);
505 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc, std::vector<T>(
506 QuantizedVector<T>(qScale, qOffset, {
512 // Use 1 batch of a 1-channel 2x2 kernel.
513 armnn::TensorInfo kernelDesc({1, 1, 2, 2}, ArmnnType);
514 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc, std::vector<T>(
515 QuantizedVector<T>(qScale, qOffset, {
520 // Expected output is 1 batch of a 1-channel 6x8 image.
521 // Manually calculated like this:
522 //[-11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ..]
523 //[-11*0 -21*0 -12*0 -22*11 ; -11*0 -21*0 -12*11 -22*21 ; -11*0 -21*0 -12*21 -22*31 ; -11*0 -21*0 -12*31 -22*0 ..]
524 //[-11*0 -21*11 -12*0 -22*12 ; -11*11 -21*21 -12*12 -22*22 ; -11*21 -21*31 -12*22 -22*32 ; -11*31 -21*0 -12*32 -22*0 ..]
525 //[-11*0 -21*12 -12*0 -22*13 ; -11*12 -21*22 -12*13 -22*23 ; -11*22 -21*32 -12*23 -22*33 ; -11*32 -21*0 -12*33 -22*0 ..]
526 //[-11*0 -21*13 -12*0 -22*0 ; -11*13 -21*23 -12*0 -22*0 ; -11*23 -21*33 -12*0 -22*0 ; -11*33 -21*0 -12*0 -22*0 ..]
527 //[-11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ; -11*0 -21*0 -12*0 -22*0 ..]
528 //[..... ..... ..... ..... ; ..... ..... ..... ..... ; ..... ..... ..... ..... ; ..... ..... ..... ..... ..]
529 armnn::TensorInfo outputDesc({1, 1, 8, 6}, ArmnnType);
530 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, std::vector<T>(
531 QuantizedVector<T>(qScale, qOffset, {
533 -242, -594, -934, -372, 0, 0,
534 -495, -1190, -1850, -725, 0, 0,
535 -538, -1256, -1916, -748, 0, 0,
536 -273, -626, -946, -363, 0, 0,
542 return SimpleConvolution2dTestImpl<ArmnnType, ArmnnBType>(
547 GetBias2<ArmnnBType>(false, qScale * qScale),
555 4); // Padding bottom.
558 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
559 typename T = armnn::ResolveType<ArmnnType>>
560 LayerTestResult<T, 4> SimpleConvolution2dAsymmetricPaddingTestCommon(
561 armnn::IWorkloadFactory& workloadFactory,
562 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
563 const armnn::DataLayout layout,
567 // Use a single-batch 1-channel 5x5 image as input.
568 armnn::TensorInfo inputDesc({ 1, 1, 5, 5 }, ArmnnType);
569 boost::multi_array<T, 4> input = MakeTensor<T, 4>(inputDesc, std::vector<T>(
570 QuantizedVector<T>(qScale, qOffset, {
578 // Use 1 batch of a 1-channel 4x4 kernel.
579 armnn::TensorInfo kernelDesc({ 1, 1, 4, 4 }, ArmnnType);
580 boost::multi_array<T, 4> kernel = MakeTensor<T, 4>(kernelDesc, std::vector<T>(
581 QuantizedVector<T>(qScale, qOffset, {
588 // Expected output is 1 batch of a 1-channel 5x5 image.
589 armnn::TensorInfo outputDesc({ 1, 1, 5, 5 }, ArmnnType);
590 std::vector<T> myVec(outputDesc.GetNumElements(), 0);
591 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputDesc, std::vector<T>(
592 QuantizedVector<T>(qScale, qOffset, {
593 -7140, -10580, -13940, -9300, -5230,
594 -9590, -14120, -18520, -12290, -6860,
595 -9980, -14560, -18960, -12560, -7000,
596 -7518, -10904, -14144, -9318, -5152,
597 -5032, -7256, -9376, -6142, -3368,
600 return SimpleConvolution2dTestImpl<ArmnnType, ArmnnBType>(
605 GetBias2<ArmnnBType>(false, qScale * qScale),
613 2); // Padding bottom.
616 LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(
617 armnn::IWorkloadFactory& workloadFactory,
618 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
619 armnn::DataLayout layout)
621 return SimpleConvolution2dAsymmetricPaddingTestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
622 workloadFactory, memoryManager, layout, 0.0f, 0);
625 LayerTestResult<float, 4> Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(
626 armnn::IWorkloadFactory& workloadFactory,
627 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
628 armnn::DataLayout layout)
630 return Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTestCommon
631 <armnn::DataType::Float32, armnn::DataType::Float32>(
632 workloadFactory, memoryManager, layout, 0.0f, 0);
635 LayerTestResult<float, 4> Convolution1dTest(
636 armnn::IWorkloadFactory& workloadFactory,
637 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
640 return Convolution1dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
641 workloadFactory, memoryManager, 0.0f, 0, biasEnabled);
644 LayerTestResult<uint8_t, 4> Convolution1dUint8Test(
645 armnn::IWorkloadFactory& workloadFactory,
646 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
649 return Convolution1dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
650 workloadFactory, memoryManager, 0.1f, 128, biasEnabled);
653 LayerTestResult<float,4> CompareConvolution2dTest(
654 armnn::IWorkloadFactory& workloadFactory,
655 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
656 armnn::IWorkloadFactory& refWorkloadFactory)
658 return CompareConvolution2dTestImpl<armnn::DataType::Float32>(
659 workloadFactory, memoryManager, refWorkloadFactory);
662 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
663 LayerTestResult<T, 4> Convolution2d3x3DilationTestCommon(
664 armnn::IWorkloadFactory& workloadFactory,
665 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
666 const std::vector<float>& inputNoQuantizedValues,
667 armnn::TensorInfo& inputTensorInfo,
668 const std::vector<float>& kernelNoQuantizedValues,
669 armnn::TensorInfo& kernelTensorInfo,
670 const std::vector<float>& outputExpectedNoQuantizedValues,
671 armnn::TensorInfo& outputTensorInfo,
674 armnn::DataLayout layout = armnn::DataLayout::NCHW,
675 uint32_t padLeft = 0,
677 uint32_t padRight = 0,
678 uint32_t padBottom = 0,
679 uint32_t strideX = 1,
680 uint32_t strideY = 1,
681 bool biasEnabled = false
688 case armnn::DataType::QuantisedAsymm8:
694 case armnn::DataType::QuantisedSymm16:
700 case armnn::DataType::Float32:
709 inputTensorInfo.SetQuantizationScale(qScale);
710 inputTensorInfo.SetQuantizationOffset(qOffset);
711 kernelTensorInfo.SetQuantizationScale(qScale);
712 kernelTensorInfo.SetQuantizationOffset(qOffset);
713 outputTensorInfo.SetQuantizationScale(qScale);
714 outputTensorInfo.SetQuantizationOffset(qOffset);
716 auto input = MakeTensor<T, 4>(inputTensorInfo,
717 std::vector<T>(QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
718 inputTensorInfo.GetQuantizationOffset(),
719 inputNoQuantizedValues)));
720 auto kernel = MakeTensor<T, 4>(kernelTensorInfo,
721 std::vector<T>(QuantizedVector<T>(kernelTensorInfo.GetQuantizationScale(),
722 kernelTensorInfo.GetQuantizationOffset(),
723 kernelNoQuantizedValues)));
724 auto expectedOutput = MakeTensor<T, 4>(outputTensorInfo,
725 std::vector<T>(QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
726 outputTensorInfo.GetQuantizationOffset(),
727 outputExpectedNoQuantizedValues)));
729 return SimpleConvolution2dTestImpl<ArmnnType, ArmnnBType>(
734 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
749 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
750 LayerTestResult<T, 4> Convolution2d3x3Dilation3x3Test(
751 armnn::IWorkloadFactory& workloadFactory,
752 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
754 const armnn::DataLayout layout)
756 armnn::TensorInfo inputTensorInfo({1, 1, 10, 10}, ArmnnType);
757 std::vector<float> inputNoQuantizedValues =
759 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
760 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
761 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
762 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
763 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
764 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
765 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
766 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
767 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
768 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
771 armnn::TensorInfo kernelTensorInfo({ 1, 1, 3, 3}, ArmnnType);
772 std::vector<float> kernelNoQuantizedValues =
779 // Since the dilation rate is 3 this will dilate the kernel to be like 7x7,
780 // therefore the output will be 4x4: (I−K+2P)/S +1 => (10-7 +0)/1 +1
781 armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4}, ArmnnType);
782 std::vector<float> outputExpectedNoQuantizedValues =
790 return Convolution2d3x3DilationTestCommon<ArmnnType, ArmnnBType>(
793 inputNoQuantizedValues,
795 kernelNoQuantizedValues,
797 outputExpectedNoQuantizedValues,
805 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
806 LayerTestResult<T, 4> Convolution2d2x3x3Dilation3x3Test(
807 armnn::IWorkloadFactory& workloadFactory,
808 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
810 const armnn::DataLayout layout)
812 armnn::TensorInfo inputTensorInfo({1, 2, 10, 10}, ArmnnType);
813 std::vector<float> inputNoQuantizedValues =
815 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
816 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
817 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
818 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
819 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
820 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
821 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
822 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
823 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
824 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
826 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
827 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
828 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
829 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
830 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
831 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
832 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
833 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
834 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
835 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
838 armnn::TensorInfo kernelTensorInfo({ 1, 2, 3, 3}, ArmnnType);
839 std::vector<float> kernelNoQuantizedValues =
850 // Since the dilation rate is 3 this will dilate the kernel to be like 7x7,
851 // therefore the output will be 4x4: (I−K+2P)/S +1 => (10-7 +0)/1 +1
852 armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4}, ArmnnType);
853 std::vector<float> outputExpectedNoQuantizedValues =
861 return Convolution2d3x3DilationTestCommon<ArmnnType, ArmnnBType>(
864 inputNoQuantizedValues,
866 kernelNoQuantizedValues,
868 outputExpectedNoQuantizedValues,
876 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
877 LayerTestResult<T, 4> Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test(
878 armnn::IWorkloadFactory &workloadFactory,
879 const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
881 const armnn::DataLayout layout)
883 armnn::TensorInfo inputTensorInfo({1, 1, 10, 10}, ArmnnType);
884 std::vector<float> inputNoQuantizedValues =
886 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
887 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
888 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
889 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
890 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
891 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
892 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
893 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
894 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
895 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
898 armnn::TensorInfo kernelTensorInfo({ 1, 1, 2, 2}, ArmnnType);
899 std::vector<float> kernelNoQuantizedValues =
905 // Since the dilation rate is 2 this will dilate the kernel to be like 3x3: d(K-1)+1 --> 2 x (2-1) + 1 = 3,
906 // therefore the output will be 4x4: (I − K + 2P)/S +1 => trunc ( (10 - 3 + 2x2 ) / 3 + 1 )
907 // where, dilation size = d = 2; kernel size = K = 2; input size = I = 10; padding size = P = 2; stride = S = 3
908 armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4}, ArmnnType);
909 std::vector<float> outputExpectedNoQuantizedValues =
916 uint32_t padLeft = 1;
918 uint32_t padRight = 1;
919 uint32_t padBottom = 1;
921 return Convolution2d3x3DilationTestCommon<ArmnnType, ArmnnBType>(
924 inputNoQuantizedValues,
926 kernelNoQuantizedValues,
928 outputExpectedNoQuantizedValues,
943 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
944 Convolution2d3x3Dilation3x3Test<armnn::DataType::Float32, armnn::DataType::Float32>(
945 armnn::IWorkloadFactory&,
946 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
950 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
951 Convolution2d3x3Dilation3x3Test<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
952 armnn::IWorkloadFactory&,
953 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
957 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
958 Convolution2d3x3Dilation3x3Test<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
959 armnn::IWorkloadFactory&,
960 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
964 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
965 Convolution2d2x3x3Dilation3x3Test<armnn::DataType::Float32, armnn::DataType::Float32>(
966 armnn::IWorkloadFactory&,
967 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
971 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
972 Convolution2d2x3x3Dilation3x3Test<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
973 armnn::IWorkloadFactory&,
974 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
978 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
979 Convolution2d2x3x3Dilation3x3Test<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
980 armnn::IWorkloadFactory&,
981 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
985 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
986 Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<armnn::DataType::Float32, armnn::DataType::Float32>(
987 armnn::IWorkloadFactory &workloadFactory,
988 const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
990 const armnn::DataLayout layout);
992 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
993 Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
994 armnn::IWorkloadFactory &workloadFactory,
995 const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
997 const armnn::DataLayout layout);
999 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
1000 Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
1001 armnn::IWorkloadFactory &workloadFactory,
1002 const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
1004 const armnn::DataLayout layout);
1006 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
1007 typename T = armnn::ResolveType<ArmnnType>>
1008 LayerTestResult<T, 4> DepthwiseConvolution2dAsymmetricTestCommon(
1009 armnn::IWorkloadFactory& workloadFactory,
1010 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1014 const armnn::DataLayout layout)
1016 // Use a single-batch 2-channel 5x5 image as input.
1017 armnn::TensorInfo inputTensorInfo({ 1, 2, 5, 5 }, ArmnnType);
1018 auto input = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(
1019 QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(), inputTensorInfo.GetQuantizationOffset(),
1034 // Use a depth multiplier of 1 on a 2-channel 4x4 kernel.
1035 armnn::TensorInfo kernelTensorInfo({ 1, 2, 4, 4 }, ArmnnType);
1036 auto kernel = MakeTensor<T, 4>(kernelTensorInfo, std::vector<T>(
1037 QuantizedVector<T>(kernelTensorInfo.GetQuantizationScale(), kernelTensorInfo.GetQuantizationOffset(),
1050 // Expected output is 1 batch of a 2-channel 5x5 image.
1051 // Calculated using the python tensorflow library with strideX=1, strideY=1.
1052 armnn::TensorInfo outputTensorInfo({ 1, 2, 5, 5 }, ArmnnType);
1053 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputTensorInfo, std::vector<T>(
1054 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(), outputTensorInfo.GetQuantizationOffset(),
1056 1062, 1580, 1850, 1530, 1117,
1057 2140, 3108, 3500, 2842, 2042,
1058 3580, 5068, 5460, 4342, 3062,
1059 3618, 5072, 5390, 4248, 2971,
1060 3074, 4282, 4510, 3533, 2457,
1062 1550, 2284, 2362, 1955, 1428,
1063 2910, 4206, 4342, 3528, 2536,
1064 3390, 4886, 5022, 4068, 2916,
1065 3566, 5056, 5182, 4133, 2922,
1066 3100, 4352, 4452, 3517, 2465
1069 return DepthwiseConvolution2dAsymmetricTestImpl<ArmnnType, ArmnnBType>(
1074 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
1081 2, // Padding right.
1082 2, // Padding bottom.
1087 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
1088 typename T = armnn::ResolveType<ArmnnType>>
1089 LayerTestResult<T, 4> DepthwiseConvolution2dNhwcTestCommon(
1090 armnn::IWorkloadFactory& workloadFactory,
1091 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1096 auto layout = armnn::DataLayout::NHWC;
1098 armnn::TensorInfo inputTensorInfo({ 1, 2, 5, 5}, ArmnnType);
1099 auto input = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(
1100 QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(), inputTensorInfo.GetQuantizationOffset(),
1115 armnn::TensorInfo kernelTensorInfo({ 1, 2, 4, 4 }, ArmnnType);
1116 auto kernel = MakeTensor<T, 4>(kernelTensorInfo, std::vector<T>(
1117 QuantizedVector<T>(kernelTensorInfo.GetQuantizationScale(), kernelTensorInfo.GetQuantizationOffset(),
1130 armnn::TensorInfo outputTensorInfo({ 1, 2, 5, 5}, ArmnnType);
1131 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputTensorInfo, std::vector<T>(
1132 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(), outputTensorInfo.GetQuantizationOffset(),
1134 1062, 1580, 1850, 1530, 1117,
1135 2140, 3108, 3500, 2842, 2042,
1136 3580, 5068, 5460, 4342, 3062,
1137 3618, 5072, 5390, 4248, 2971,
1138 3074, 4282, 4510, 3533, 2457,
1140 1550, 2284, 2362, 1955, 1428,
1141 2910, 4206, 4342, 3528, 2536,
1142 3390, 4886, 5022, 4068, 2916,
1143 3566, 5056, 5182, 4133, 2922,
1144 3100, 4352, 4452, 3517, 2465
1147 return DepthwiseConvolution2dTestImpl<ArmnnType, ArmnnBType>(
1152 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
1159 2, // Padding right.
1160 2, // Padding bottom.
1165 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType,
1166 typename T = armnn::ResolveType<ArmnnType>>
1167 LayerTestResult<T, 4> SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTestCommon(
1168 armnn::IWorkloadFactory& workloadFactory,
1169 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1174 auto layout = armnn::DataLayout::NHWC;
1176 armnn::TensorInfo inputTensorInfo({ 1, 1, 9, 9}, ArmnnType);
1177 auto input = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(
1178 QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(), inputTensorInfo.GetQuantizationOffset(),
1180 0, 0, 0, 0, 0, 0, 0, 0, 0,
1181 0, 0, 0, 0, 0, 0, 0, 0, 0,
1182 0, 0, 0, 0, 0, 0, 0, 0, 0,
1183 0, 0, 0, 1, 1, 1, 0, 0, 0,
1184 0, 0, 0, 1, 1, 1, 0, 0, 0,
1185 0, 0, 0, 1, 1, 1, 0, 0, 0,
1186 0, 0, 0, 0, 0, 0, 0, 0, 0,
1187 0, 0, 0, 0, 0, 0, 0, 0, 0,
1188 0, 0, 0, 0, 0, 0, 0, 0, 0
1191 armnn::TensorInfo kernelTensorInfo({ 1, 1, 3, 3}, ArmnnType);
1192 auto kernel = MakeTensor<T, 4>(kernelTensorInfo, std::vector<T>(
1193 QuantizedVector<T>(kernelTensorInfo.GetQuantizationScale(), kernelTensorInfo.GetQuantizationOffset(),
1200 uint32_t padLeft = 0;
1201 uint32_t padTop = 0;
1202 uint32_t padRight = 0;
1203 uint32_t padBottom = 0;
1204 uint32_t strideX = 1;
1205 uint32_t strideY = 1;
1206 uint32_t dilationX = 3;
1207 uint32_t dilationY = 3;
1209 // Since the dilation rate is 3 this will reduce the size of the output from 9x9 to 3x3 of all 5s.
1210 armnn::TensorInfo outputTensorInfo({ 1, 1, 3, 3}, ArmnnType);
1211 boost::multi_array<T, 4> expectedOutput = MakeTensor<T, 4>(outputTensorInfo, std::vector<T>(
1212 QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(), outputTensorInfo.GetQuantizationOffset(),
1219 return DepthwiseConvolution2dTestImpl<ArmnnType, ArmnnBType>(
1224 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
1240 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
1241 LayerTestResult<T, 4> DepthwiseConvolution2d3x3DilationTestCommon(
1242 armnn::IWorkloadFactory& workloadFactory,
1243 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1244 const std::vector<float>& inputNoQuantizedValues,
1245 armnn::TensorInfo& inputTensorInfo,
1246 const std::vector<float>& kernelNoQuantizedValues,
1247 armnn::TensorInfo& kernelTensorInfo,
1248 const std::vector<float>& outputExpectedNoQuantizedValues,
1249 armnn::TensorInfo& outputTensorInfo,
1252 armnn::DataLayout layout = armnn::DataLayout::NCHW,
1253 bool biasEnabled = false)
1259 case armnn::DataType::QuantisedAsymm8:
1265 case armnn::DataType::QuantisedSymm16:
1271 case armnn::DataType::Float32:
1280 inputTensorInfo.SetQuantizationScale(qScale);
1281 inputTensorInfo.SetQuantizationOffset(qOffset);
1282 kernelTensorInfo.SetQuantizationScale(qScale);
1283 kernelTensorInfo.SetQuantizationOffset(qOffset);
1284 outputTensorInfo.SetQuantizationScale(qScale);
1285 outputTensorInfo.SetQuantizationOffset(qOffset);
1287 auto input = MakeTensor<T, 4>(inputTensorInfo,
1288 std::vector<T>(QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
1289 inputTensorInfo.GetQuantizationOffset(),
1290 inputNoQuantizedValues)));
1291 auto kernel = MakeTensor<T, 4>(kernelTensorInfo,
1292 std::vector<T>(QuantizedVector<T>(kernelTensorInfo.GetQuantizationScale(),
1293 kernelTensorInfo.GetQuantizationOffset(),
1294 kernelNoQuantizedValues)));
1295 auto expectedOutput = MakeTensor<T, 4>(outputTensorInfo,
1296 std::vector<T>(QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
1297 outputTensorInfo.GetQuantizationOffset(),
1298 outputExpectedNoQuantizedValues)));
1300 uint32_t padLeft = 0;
1301 uint32_t padTop = 0;
1302 uint32_t padRight = 0;
1303 uint32_t padBottom = 0;
1304 uint32_t strideX = 1;
1305 uint32_t strideY = 1;
1307 return DepthwiseConvolution2dTestImpl<ArmnnType, ArmnnBType>(
1312 GetBias2<ArmnnBType>(biasEnabled, qScale * qScale),
1327 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
1328 LayerTestResult<T, 4> DepthwiseConvolution2d3x3Dilation3x3Test(
1329 armnn::IWorkloadFactory& workloadFactory,
1330 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1332 const armnn::DataLayout layout)
1334 armnn::TensorInfo inputTensorInfo({1, 1, 10, 10}, ArmnnType);
1335 std::vector<float> inputNoQuantizedValues =
1337 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1338 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1339 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1340 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1341 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1342 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1343 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1344 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1345 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1346 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1349 armnn::TensorInfo kernelTensorInfo({ 1, 1, 3, 3}, ArmnnType);
1350 std::vector<float> kernelNoQuantizedValues =
1357 // Since the dilation rate is 3 this will dilate the kernel to be like 7x7,
1358 // therefore the output will be 4x4: (I−K+2P)/S +1 => (10-7 +0)/1 +1
1359 armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4}, ArmnnType);
1360 std::vector<float> outputExpectedNoQuantizedValues =
1368 return DepthwiseConvolution2d3x3DilationTestCommon<ArmnnType, ArmnnBType>(
1371 inputNoQuantizedValues,
1373 kernelNoQuantizedValues,
1375 outputExpectedNoQuantizedValues,
1383 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T>
1384 LayerTestResult<T, 4> DepthwiseConvolution2d2x3x3Dilation3x3Test(
1385 armnn::IWorkloadFactory& workloadFactory,
1386 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1388 const armnn::DataLayout layout)
1390 armnn::TensorInfo inputTensorInfo({1, 2, 10, 10}, ArmnnType);
1391 std::vector<float> inputNoQuantizedValues =
1393 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1394 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1395 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1396 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1397 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1398 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1399 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1400 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1401 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1402 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1404 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1405 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1407 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1408 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1409 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1410 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1411 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1412 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1413 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1416 armnn::TensorInfo kernelTensorInfo({ 1, 2, 3, 3}, ArmnnType);
1417 std::vector<float> kernelNoQuantizedValues =
1428 // Since the dilation rate is 3 this will dilate the kernel to be like 7x7,
1429 // therefore the output will be 2x4x4: (I−K+2P)/S +1 => (10-7 +0)/1 +1
1430 armnn::TensorInfo outputTensorInfo({ 1, 2, 4, 4}, ArmnnType);
1431 std::vector<float> outputExpectedNoQuantizedValues =
1444 return DepthwiseConvolution2d3x3DilationTestCommon<ArmnnType, ArmnnBType>(
1447 inputNoQuantizedValues,
1449 kernelNoQuantizedValues,
1451 outputExpectedNoQuantizedValues,
1460 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
1461 DepthwiseConvolution2d3x3Dilation3x3Test<armnn::DataType::Float32, armnn::DataType::Float32>(
1462 armnn::IWorkloadFactory&,
1463 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1467 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
1468 DepthwiseConvolution2d3x3Dilation3x3Test<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
1469 armnn::IWorkloadFactory&,
1470 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1474 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
1475 DepthwiseConvolution2d3x3Dilation3x3Test<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
1476 armnn::IWorkloadFactory&,
1477 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1481 template LayerTestResult<armnn::ResolveType<armnn::DataType::Float32>, 4>
1482 DepthwiseConvolution2d2x3x3Dilation3x3Test<armnn::DataType::Float32, armnn::DataType::Float32>(
1483 armnn::IWorkloadFactory&,
1484 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1488 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
1489 DepthwiseConvolution2d2x3x3Dilation3x3Test<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
1490 armnn::IWorkloadFactory&,
1491 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1495 template LayerTestResult<armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
1496 DepthwiseConvolution2d2x3x3Dilation3x3Test<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
1497 armnn::IWorkloadFactory&,
1498 const armnn::IBackendInternal::IMemoryManagerSharedPtr&,
1502 LayerTestResult<float, 4> DepthwiseConvolution2dTest(
1503 armnn::IWorkloadFactory& workloadFactory,
1504 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1506 const armnn::DataLayout layout)
1508 return DepthwiseConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
1509 workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
1512 LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(
1513 armnn::IWorkloadFactory& workloadFactory,
1514 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1517 return DepthwiseConvolution2dNhwcTestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
1518 workloadFactory, memoryManager, 0.0f, 0, biasEnabled);
1521 LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(
1522 armnn::IWorkloadFactory& workloadFactory,
1523 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1525 const armnn::DataLayout layout)
1527 return DepthwiseConvolution2dDepthMul1TestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
1528 workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
1531 LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul64Test(
1532 armnn::IWorkloadFactory& workloadFactory,
1533 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
1535 armnn::TensorInfo inputTensorInfo({ 1, 1, 2, 2 }, armnn::DataType::Float32);
1536 auto input = MakeTensor<float, 4>(inputTensorInfo, { 1.f, 2.f, 3.f, 4.f });
1538 std::vector<float> kernelData;
1539 std::vector<float> singleDepthKernel{ 1.f, -1.f, -1.f, 1.f };
1540 for (unsigned int i = 0; i < 64; ++i)
1542 kernelData.insert(kernelData.end(), singleDepthKernel.begin(), singleDepthKernel.end());
1544 armnn::TensorInfo kernelTensorInfo({ 64, 1, 2, 2 }, armnn::DataType::Float32);
1545 auto kernel = MakeTensor<float, 4>(kernelTensorInfo, kernelData);
1547 std::vector<float> expectedOutputData(64, 0.f);
1548 armnn::TensorInfo outputTensorInfo({ 1, 64, 1, 1 }, armnn::DataType::Float32);
1549 auto expectedOutput = MakeTensor<float, 4>(outputTensorInfo, expectedOutputData);
1551 return DepthwiseConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
1556 boost::multi_array<float, 1>(),
1560 armnn::DataLayout::NCHW);
1563 LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(
1564 armnn::IWorkloadFactory& workloadFactory,
1565 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1567 const armnn::DataLayout layout)
1569 return DepthwiseConvolution2dAsymmetricTestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
1570 workloadFactory, memoryManager, 0.0f, 0, biasEnabled, layout);
1573 LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(
1574 armnn::IWorkloadFactory& workloadFactory,
1575 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1577 const armnn::DataLayout layout)
1579 return DepthwiseConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
1580 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
1583 LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(
1584 armnn::IWorkloadFactory& workloadFactory,
1585 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1587 const armnn::DataLayout layout)
1589 return DepthwiseConvolution2dDepthMul1TestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
1590 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
1593 LayerTestResult<float, 4> SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest(
1594 armnn::IWorkloadFactory& workloadFactory,
1595 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
1597 return SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTestCommon<armnn::DataType::Float32, armnn::DataType::Float32>(
1605 LayerTestResult<int16_t, 4> DepthwiseConvolution2dInt16Test(
1606 armnn::IWorkloadFactory& workloadFactory,
1607 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1609 const armnn::DataLayout layout)
1611 return DepthwiseConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
1612 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
1615 LayerTestResult<int16_t, 4> DepthwiseConvolution2dDepthMul1Int16Test(
1616 armnn::IWorkloadFactory& workloadFactory,
1617 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1619 const armnn::DataLayout layout)
1621 return DepthwiseConvolution2dDepthMul1TestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
1622 workloadFactory, memoryManager, 0.5f, 50, biasEnabled, layout);
1625 LayerTestResult<float, 4> CompareDepthwiseConvolution2dFloatTest(
1626 armnn::IWorkloadFactory& workloadFactory,
1627 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1628 armnn::IWorkloadFactory& refWorkloadFactory,
1629 const armnn::DataLayout layout)
1631 return CompareDepthwiseConvolution2dTestImpl<armnn::DataType::Float32>(
1632 workloadFactory, memoryManager, refWorkloadFactory, layout);
1635 LayerTestResult<uint8_t, 4> CompareDepthwiseConvolution2dUint8Test(
1636 armnn::IWorkloadFactory& workloadFactory,
1637 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1638 armnn::IWorkloadFactory& refWorkloadFactory,
1639 const armnn::DataLayout layout)
1641 return CompareDepthwiseConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8>(
1642 workloadFactory, memoryManager, refWorkloadFactory, layout);
1645 LayerTestResult<float,4> SimpleNormalizationAcrossTest(
1646 armnn::IWorkloadFactory& workloadFactory,
1647 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
1649 auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
1650 auto normChannel = armnn::NormalizationAlgorithmChannel::Across;
1651 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
1654 LayerTestResult<float,4> SimpleNormalizationWithinTest(
1655 armnn::IWorkloadFactory& workloadFactory,
1656 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
1658 auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
1659 auto normChannel = armnn::NormalizationAlgorithmChannel::Within;
1660 return SimpleNormalizationTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
1663 LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(
1664 armnn::IWorkloadFactory& workloadFactory,
1665 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
1667 auto normMethod = armnn::NormalizationAlgorithmMethod::LocalBrightness;
1668 auto normChannel = armnn::NormalizationAlgorithmChannel::Across;
1669 return SimpleNormalizationNhwcTestImpl(workloadFactory, memoryManager, normChannel, normMethod);
1672 LayerTestResult<float,2> SimpleSoftmaxTest(
1673 armnn::IWorkloadFactory& workloadFactory,
1674 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1677 return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta);
1680 LayerTestResult<float,2> SimpleAxisSoftmaxTest(
1681 armnn::IWorkloadFactory& workloadFactory,
1682 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1686 return SimpleSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta, axis);
1689 LayerTestResult<float,3> Simple3dSoftmaxTest(
1690 armnn::IWorkloadFactory& workloadFactory,
1691 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1694 Simple3dSoftmaxOutputData data;
1695 return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta,
1696 data.inputShape, data.outputData, data.inputData);
1699 LayerTestResult<float,3> Simple3dAxisSoftmaxTest(
1700 armnn::IWorkloadFactory& workloadFactory,
1701 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1705 armnn::TensorShape inputShape;
1706 std::vector<float> inputData;
1707 std::vector<float> outputData;
1713 inputShape = {5, 2, 2};
1717 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f,
1719 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f
1724 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f,
1726 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f,
1729 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f,
1731 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f,
1732 7.246299848982885e-08f
1739 inputShape = {2, 5, 2};
1743 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f,
1745 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f
1750 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1752 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1753 7.246299848982885e-08f,
1755 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1757 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1758 7.246299848982885e-08f
1765 inputShape = {2, 2, 5};
1769 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f,
1770 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f
1775 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1776 7.246299848982885e-08f,
1777 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1778 7.246299848982885e-08f,
1780 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1781 7.246299848982885e-08f,
1782 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1783 7.246299848982885e-08f
1789 return Simple3dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta,
1790 inputShape, outputData, inputData, axis);
1793 LayerTestResult<float,4> Simple4dSoftmaxTest(
1794 armnn::IWorkloadFactory& workloadFactory,
1795 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1798 Simple4dSoftmaxData data;
1799 return Simple4dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta, data.inputShape,
1800 data.outputData, data.inputData);
1803 LayerTestResult<float,4> Simple4dAxisSoftmaxTest(
1804 armnn::IWorkloadFactory& workloadFactory,
1805 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1809 armnn::TensorShape inputShape;
1810 std::vector<float> inputData;
1811 std::vector<float> outputData;
1817 inputShape = {5, 2, 2, 2};
1821 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f,
1822 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f,
1823 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f,
1824 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f
1829 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f,
1831 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f,
1833 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f,
1835 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f,
1838 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f,
1840 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f,
1842 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f,
1843 7.246299848982885e-08f,
1844 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f,
1845 7.246299848982885e-08f, 7.246299848982885e-08f
1852 inputShape = {2, 5, 2, 2};
1856 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f,
1857 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f,
1858 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f,
1859 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f
1864 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f,
1866 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f,
1868 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f,
1870 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f,
1871 7.246299848982885e-08f,
1874 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f,
1876 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f,
1878 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f,
1880 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f,
1881 7.246299848982885e-08f
1888 inputShape = {2, 2, 5, 2};
1892 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f,
1893 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f,
1894 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f,
1895 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f
1900 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1902 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1903 7.246299848982885e-08f,
1904 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1906 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1907 7.246299848982885e-08f,
1909 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1911 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1912 7.246299848982885e-08f,
1913 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f,
1915 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f,
1916 7.246299848982885e-08f
1923 inputShape = {2, 2, 2, 5};
1927 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f,
1928 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f,
1929 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f,
1930 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f
1935 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1936 7.246299848982885e-08f,
1937 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1938 7.246299848982885e-08f,
1939 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1940 7.246299848982885e-08f,
1941 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1942 7.246299848982885e-08f,
1944 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1945 7.246299848982885e-08f,
1946 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1947 7.246299848982885e-08f,
1948 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1949 7.246299848982885e-08f,
1950 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f,
1951 7.246299848982885e-08f
1957 return Simple4dSoftmaxTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, beta, inputShape,
1958 outputData, inputData, axis);
1961 LayerTestResult<uint8_t,2> SimpleSoftmaxUint8Test(
1962 armnn::IWorkloadFactory& workloadFactory,
1963 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1966 return SimpleSoftmaxTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, beta);
1969 LayerTestResult<uint8_t,3> Simple3dSoftmaxUint8Test(
1970 armnn::IWorkloadFactory& workloadFactory,
1971 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1974 Simple3dSoftmaxOutputData data;
1975 return Simple3dSoftmaxTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, beta,
1976 data.inputShape, data.outputData, data.inputData);
1979 LayerTestResult<uint8_t,4> Simple4dSoftmaxUint8Test(
1980 armnn::IWorkloadFactory& workloadFactory,
1981 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1984 Simple4dSoftmaxData data;
1986 return Simple4dSoftmaxTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, beta,
1987 data.inputShape, data.outputData, data.inputData);
1990 LayerTestResult<int16_t,2> SimpleSoftmaxUint16Test(
1991 armnn::IWorkloadFactory& workloadFactory,
1992 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1995 return SimpleSoftmaxTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, beta);
1998 LayerTestResult<int16_t,3> Simple3dSoftmaxUint16Test(
1999 armnn::IWorkloadFactory& workloadFactory,
2000 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2003 Simple3dSoftmaxOutputData data;
2004 return Simple3dSoftmaxTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, beta,
2005 data.inputShape, data.outputData, data.inputData);
2008 LayerTestResult<int16_t,4> Simple4dSoftmaxUint16Test(
2009 armnn::IWorkloadFactory& workloadFactory,
2010 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2013 Simple4dSoftmaxData data;
2015 return Simple4dSoftmaxTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, beta,
2016 data.inputShape, data.outputData, data.inputData);
2019 LayerTestResult<float,4> CompareNormalizationTest(
2020 armnn::IWorkloadFactory& workloadFactory,
2021 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2022 armnn::IWorkloadFactory& refWorkloadFactory,
2023 armnn::NormalizationAlgorithmChannel normChannel,
2024 armnn::NormalizationAlgorithmMethod normMethod)
2026 return CompareNormalizationTestImpl(workloadFactory, memoryManager, refWorkloadFactory, normChannel, normMethod);
2029 LayerTestResult<float,2> CompareSoftmaxTest(
2030 armnn::IWorkloadFactory& workloadFactory,
2031 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2032 armnn::IWorkloadFactory& refWorkloadFactory,
2035 return CompareSoftmaxTestImpl<armnn::DataType::Float32>(
2036 workloadFactory, memoryManager, refWorkloadFactory, beta);
2039 LayerTestResult<uint8_t,2> CompareSoftmaxUint8Test(
2040 armnn::IWorkloadFactory& workloadFactory,
2041 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2042 armnn::IWorkloadFactory& refWorkloadFactory,
2045 return CompareSoftmaxTestImpl<armnn::DataType::QuantisedAsymm8>(
2046 workloadFactory, memoryManager, refWorkloadFactory, beta);
2049 std::vector<LayerTestResult<float,3>> SplitterTest(
2050 armnn::IWorkloadFactory& workloadFactory,
2051 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2053 return SplitterTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
2056 std::vector<LayerTestResult<uint8_t,3>> SplitterUint8Test(
2057 armnn::IWorkloadFactory& workloadFactory,
2058 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2060 return SplitterTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
2063 std::vector<LayerTestResult<int16_t,3>> SplitterInt16Test(
2064 armnn::IWorkloadFactory& workloadFactory,
2065 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2067 return SplitterTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.0f, 0);
2070 LayerTestResult<float, 3> CopyViaSplitterTest(
2071 armnn::IWorkloadFactory& workloadFactory,
2072 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2074 return CopyViaSplitterTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
2077 LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(
2078 armnn::IWorkloadFactory& workloadFactory,
2079 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2081 return CopyViaSplitterTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
2084 LayerTestResult<int16_t, 3> CopyViaSplitterInt16Test(
2085 armnn::IWorkloadFactory& workloadFactory,
2086 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2088 return CopyViaSplitterTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.0f, 0);
2091 void LstmUtilsZeroVectorTest()
2093 armnn::TensorInfo inputDesc({4}, armnn::DataType::Float32);
2094 boost::multi_array<float, 1> input = MakeTensor<float, 1>(inputDesc, std::vector<float>(
2097 boost::multi_array<float, 1> expectedOutput = MakeTensor<float, 1>(inputDesc, std::vector<float>(
2100 return LstmUtilsZeroVectorTestImpl<armnn::DataType::Float32>(input, 4, expectedOutput);
2103 void LstmUtilsMeanStddevNormalizationNoneZeroInputTest()
2105 uint32_t batchSize = 2;
2106 uint32_t vecSize = 4;
2107 armnn::TensorInfo inputDesc({batchSize, vecSize}, armnn::DataType::Float32);
2108 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2109 { 0.1f, 0.2f, 0.3f, 0.4f, //batch 0
2110 0.9f, 1.0f, 1.1f, 1.2f })); //batch 1
2112 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2113 { -1.34164071f, -0.447213531f, 0.44721365f, 1.34164071f, //batch 0
2114 -1.34163153f, -0.447210163f, 0.447211236f, 1.3416326f })); //batch 1
2116 return LstmUtilsMeanStddevNormalizationTestImpl<armnn::DataType::Float32>(input,
2117 vecSize, batchSize, expectedOutput);
2120 void LstmUtilsMeanStddevNormalizationAllZeroInputTest()
2122 uint32_t batchSize = 2;
2123 uint32_t vecSize = 4;
2124 armnn::TensorInfo inputDesc({batchSize, vecSize}, armnn::DataType::Float32);
2125 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2126 { 0.0f, 0.0f, 0.0f, 0.0f, //batch 0
2127 0.0f, 0.0f, 0.0f, 0.0f })); //batch 1
2129 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2130 { 0.0f, 0.0f, 0.0f, 0.0f, //batch 0
2131 0.0f, 0.0f, 0.0f, 0.0f })); //batch 1
2133 return LstmUtilsMeanStddevNormalizationTestImpl<armnn::DataType::Float32>(input,
2134 vecSize, batchSize, expectedOutput);
2137 void LstmUtilsMeanStddevNormalizationMixedZeroInputTest()
2139 uint32_t batchSize = 2;
2140 uint32_t vecSize = 4;
2141 armnn::TensorInfo inputDesc({batchSize, vecSize}, armnn::DataType::Float32);
2142 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2143 { 0.0f, 0.0f, 0.0f, 0.0f, //batch 0
2144 0.1f, 0.2f, 0.3f, 0.4f })); //batch 1
2146 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2147 { 0.0f, 0.0f, 0.0f, 0.0f, //batch 0
2148 -1.34164071f, -0.447213531f, 0.44721365f, 1.34164071f })); //batch 1
2150 return LstmUtilsMeanStddevNormalizationTestImpl<armnn::DataType::Float32>(input,
2151 vecSize, batchSize, expectedOutput);
2155 void LstmUtilsVectorBatchVectorCwiseProductTest()
2157 uint32_t batchSize = 4;
2158 uint32_t vecSize = 29;
2159 armnn::TensorInfo vecDesc({vecSize}, armnn::DataType::Float32);
2160 boost::multi_array<float, 1> vector = MakeTensor<float, 1>(vecDesc, std::vector<float>(
2161 { 1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f, 7.7f, 8.8f, 9.9f, 10.1f,
2162 11.11f, 12.12f, 13.13f, 14.14f, 15.15f, 16.16f, 17.17f, 18.18f, 19.19f, 20.2f,
2163 21.21f, 22.22f, 23.23f, 24.24f, 25.25f, 26.26f, 27.27f, 28.28f, 0.0f}));
2165 armnn::TensorInfo batchVecDesc({batchSize, vecSize}, armnn::DataType::Float32);
2166 boost::multi_array<float, 2> batchVector = MakeTensor<float, 2>(batchVecDesc, std::vector<float>(
2168 1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f, 7.7f, 8.8f, 9.9f, 10.1f,
2169 11.11f, 12.12f, 13.13f, 14.14f, 15.15f, 16.16f, 17.17f, 18.18f, 19.19f, 20.2f,
2170 21.21f, 22.22f, 23.23f, 24.24f, 25.25f, 26.26f, 27.27f, 28.28f, 0.0f,
2172 -1.1f, -2.2f, -3.3f, -4.4f, -5.5f, -6.6f, -7.7f, -8.8f, -9.9f, -10.1f,
2173 -11.11f, -12.12f, -13.13f, -14.14f, -15.15f, -16.16f, -17.17f, -18.18f, -19.19f, -20.2f,
2174 -21.21f, -22.22f, -23.23f, -24.24f, -25.25f, -26.26f, -27.27f, -28.28f, 0.0f,
2176 1.1f, -2.2f, 3.3f, -4.4f, 5.5f, -6.6f, 7.7f, -8.8f, 9.9f, -10.1f,
2177 11.11f, -12.12f, 13.13f, -14.14f, 15.15f, -16.16f, 17.17f, -18.18f, 19.19f, -20.2f,
2178 21.21f, -22.22f, 23.23f, -24.24f, 25.25f, -26.26f, 27.27f, -28.28f, 0.0f,
2180 -1.1f, 2.2f, -3.3f, 4.4f, -5.5f, 6.6f, -7.7f, 8.8f, -9.9f, 10.1f,
2181 -11.11f, 12.12f, -13.13f, 14.14f, -15.15f, 16.16f, -17.17f, 18.18f, -19.19f, 20.2f,
2182 -21.21f, 22.22f, -23.23f, 24.24f, -25.25f, 26.26f, -27.27f, 28.28f, 0.0f}));
2184 // Expect output = input * output + output.
2185 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(batchVecDesc, std::vector<float>(
2187 1.210000f, 4.840000f, 10.889999f, 19.360001f, 30.250000f, 43.559998f,
2188 59.289997f, 77.440002f, 98.009995f, 102.010010f, 123.432091f, 146.894394f,
2189 172.396896f, 199.939606f, 229.522491f, 261.145599f, 294.808899f, 330.512421f,
2190 368.256134f, 408.040039f, 449.864075f, 493.728363f, 539.632874f, 587.577576f,
2191 637.562500f, 689.587585f, 743.652954f, 799.758423f, 0.000000f,
2193 -1.210000f, -4.840000f, -10.889999f, -19.360001f, -30.250000f, -43.559998f,
2194 -59.289997f, -77.440002f, -98.009995f, -102.010010f, -123.432091f, -146.894394f,
2195 -172.396896f, -199.939606f, -229.522491f, -261.145599f, -294.808899f, -330.512421f,
2196 -368.256134f, -408.040039f, -449.864075f, -493.728363f, -539.632874f, -587.577576f,
2197 -637.562500f, -689.587585f, -743.652954f, -799.758423f, 0.000000f,
2199 1.210000f, -4.840000f, 10.889999f, -19.360001f, 30.250000f, -43.559998f,
2200 59.289997f, -77.440002f, 98.009995f, -102.010010f, 123.432091f, -146.894394f,
2201 172.396896f, -199.939606f, 229.522491f, -261.145599f, 294.808899f, -330.512421f,
2202 368.256134f, -408.040039f, 449.864075f, -493.728363f, 539.632874f, -587.577576f,
2203 637.562500f, -689.587585f, 743.652954f, -799.758423f, 0.000000f,
2205 -1.210000f, 4.840000f, -10.889999f, 19.360001f, -30.250000f, 43.559998f,
2206 -59.289997f, 77.440002f, -98.009995f, 102.010010f, -123.432091f, 146.894394f,
2207 -172.396896f, 199.939606f, -229.522491f, 261.145599f, -294.808899f, 330.512421f,
2208 -368.256134f, 408.040039f, -449.864075f, 493.728363f, -539.632874f, 587.577576f,
2209 -637.562500f, 689.587585f, -743.652954f, 799.758423f, 0.000000f}));
2211 return LstmUtilsVectorBatchVectorCwiseProductTestImpl<armnn::DataType::Float32>(vector, batchVector,
2212 vecSize, batchSize, expectedOutput);
2216 void LstmUtilsVectorBatchVectorAddTest()
2218 uint32_t batchSize = 2;
2219 uint32_t vecSize = 3;
2220 armnn::TensorInfo vecDesc({vecSize}, armnn::DataType::Float32);
2221 boost::multi_array<float, 1> vector = MakeTensor<float, 1>(vecDesc, std::vector<float>(
2222 { 0.0f, -0.5f, 1.0f}));
2224 armnn::TensorInfo batchVecDesc({batchSize, vecSize}, armnn::DataType::Float32);
2225 boost::multi_array<float, 2> batchVector = MakeTensor<float, 2>(batchVecDesc, std::vector<float>(
2226 { 1.0f, 2.0f, 3.0f, //batch 0
2227 4.0f, 5.0f, 6.0f})); //batch 1
2229 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(batchVecDesc, std::vector<float>(
2231 4.0f, 4.5f, 7.0f}));
2233 return LstmUtilsVectorBatchVectorAddTestImpl<armnn::DataType::Float32>(vector, batchVector,
2234 vecSize, batchSize, expectedOutput);
2238 LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest(
2239 armnn::IWorkloadFactory& workloadFactory,
2240 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2242 armnn::TensorInfo inputDesc({ 2, 2 }, armnn::DataType::Float32);
2243 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2244 { 2., 3., 3., 4. }));
2246 armnn::TensorInfo outputDesc({ 2, 4 }, armnn::DataType::Float32);
2247 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(outputDesc, std::vector<float>(
2248 {-0.36444446f, -0.00352185f, 0.12886585f, -0.05163646f,
2249 -0.42734814f, -0.00478661f, 0.13455015f, -0.03560682f}));
2250 return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl<armnn::DataType::Float32>(
2251 workloadFactory, memoryManager, input, expectedOutput);
2254 LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(
2255 armnn::IWorkloadFactory& workloadFactory,
2256 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2258 armnn::TensorInfo inputDesc({ 2, 5 }, armnn::DataType::Float32);
2259 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2260 {0.787926f, 0.151646f, 0.071352f, 0.118426f, 0.458058f,
2261 0.295743f, 0.544053f, 0.690064f, 0.858138f, 0.497181f}));
2263 armnn::TensorInfo outputDesc({ 2, 16 }, armnn::DataType::Float32);
2264 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(outputDesc, std::vector<float>(
2265 {-0.00396806f, 0.029352f, -0.00279226f, 0.0159977f, -0.00835576f,
2266 -0.0211779f, 0.0283512f, -0.0114597f, 0.00907307f, -0.0244004f,
2267 -0.0152191f, -0.0259063f, 0.00914318f, 0.00415118f, 0.017147f,
2268 0.0134203f, -0.013869f, 0.0287268f, -0.00334693f, 0.00733398f, -0.0287926f,
2269 -0.0186926f, 0.0193662f, -0.0115437f, 0.00422612f, -0.0345232f,
2270 0.00223253f, -0.00957321f, 0.0210624f, 0.013331f, 0.0150954f,
2272 return LstmLayerNoCifgWithPeepholeWithProjectionTestImpl<armnn::DataType::Float32>(
2273 workloadFactory, memoryManager, input, expectedOutput);
2276 LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(
2277 armnn::IWorkloadFactory& workloadFactory,
2278 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2280 armnn::TensorInfo inputDesc({2, 2}, armnn::DataType::Float32);
2281 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2285 armnn::TensorInfo outputDesc({2, 4}, armnn::DataType::Float32);
2286 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(outputDesc, std::vector<float>(
2287 {{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f,
2288 -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}}));
2290 return LstmNoCifgNoPeepholeNoProjectionTestImpl<armnn::DataType::Float32>(
2291 workloadFactory, memoryManager, input, expectedOutput);
2295 LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest(
2296 armnn::IWorkloadFactory& workloadFactory,
2297 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2299 armnn::TensorInfo inputDesc({ 2, 5 }, armnn::DataType::Float32);
2300 boost::multi_array<float, 2> input = MakeTensor<float, 2>(inputDesc, std::vector<float>(
2301 {0.7f, 0.8f, 0.1f, 0.2f, 0.3f, //batch 0
2302 0.3f, 0.2f, 0.9f, 0.8f, 0.1f})); //batch 1
2304 armnn::TensorInfo outputDesc({ 2, 3 }, armnn::DataType::Float32);
2305 boost::multi_array<float, 2> expectedOutput = MakeTensor<float, 2>(outputDesc, std::vector<float>(
2306 { 0.0244077f, 0.128027f, -0.00170918f, //batch 0
2307 -0.00692428f, 0.0848741f, 0.063445f})); //batch 1
2308 return LstmLayerNoCifgWithPeepholeWithProjectionWithLayerNormTestImpl<armnn::DataType::Float32>(
2309 workloadFactory, memoryManager, input, expectedOutput);
2313 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionTest(
2314 armnn::IWorkloadFactory& workloadFactory,
2315 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2317 const float qScale = 1.0f;
2318 const int32_t qOffset = 0;
2320 const armnn::DataType datatype = armnn::DataType::QuantisedSymm16;
2321 const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8;
2323 armnn::TensorInfo inputDesc({2, 2}, datatype);
2324 boost::multi_array<int16_t , 2> input = MakeTensor<int16_t , 2>(inputDesc, QuantizedVector<int16_t>(qScale, qOffset,
2325 std::vector<float>{2., 3., 3., 4.}));
2327 armnn::TensorInfo outputDesc({2, 4}, datatype);
2328 boost::multi_array<int16_t, 2> expectedOutput = MakeTensor<int16_t, 2>(outputDesc, QuantizedVector<int16_t>(qScale,
2329 qOffset, std::vector<float>({{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f,
2330 -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}})));
2332 return LstmNoCifgNoPeepholeNoProjectionTestImpl<datatype>(
2333 workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype);
2337 LayerTestResult<int16_t, 2> LstmLayerInt16WithCifgWithPeepholeNoProjectionTest(
2338 armnn::IWorkloadFactory& workloadFactory,
2339 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2341 const float qScale = 1.0f;
2342 const int32_t qOffset = 0;
2344 const armnn::DataType datatype = armnn::DataType::QuantisedSymm16;
2345 const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8;
2347 armnn::TensorInfo inputDesc({ 2, 2 }, datatype);
2348 boost::multi_array<int16_t, 2> input = MakeTensor<int16_t, 2>(inputDesc, QuantizedVector<int16_t>(qScale, qOffset,
2349 std::vector<float>({ 2., 3., 3., 4. })));
2351 armnn::TensorInfo outputDesc({ 2, 4 }, datatype);
2352 boost::multi_array<int16_t, 2> expectedOutput = MakeTensor<int16_t, 2>(outputDesc, QuantizedVector<int16_t>(qScale,
2353 qOffset, std::vector<float>(
2354 {-0.36444446f, -0.00352185f, 0.12886585f, -0.05163646f,
2355 -0.42734814f, -0.00478661f, 0.13455015f, -0.03560682f})));
2357 return LstmLayerWithCifgWithPeepholeNoProjectionTestImpl<datatype>(
2358 workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype);
2361 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgWithPeepholeWithProjectionTest(
2362 armnn::IWorkloadFactory& workloadFactory,
2363 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2365 const float qScale = 2.0f;
2366 const int32_t qOffset = 0;
2368 const armnn::DataType datatype = armnn::DataType::QuantisedSymm16;
2369 const armnn::DataType constantDatatype = armnn::DataType::QuantisedAsymm8;
2371 armnn::TensorInfo inputDesc({ 2, 5 }, datatype);
2372 boost::multi_array<int16_t, 2> input = MakeTensor<int16_t, 2>(inputDesc, QuantizedVector<int16_t>(qScale,
2373 qOffset, std::vector<float>(
2374 {0.787926f, 0.151646f, 0.071352f, 0.118426f, 0.458058f,
2375 0.295743f, 0.544053f, 0.690064f, 0.858138f, 0.497181f})));
2377 armnn::TensorInfo outputDesc({ 2, 16 }, datatype);
2378 boost::multi_array<int16_t, 2> expectedOutput = MakeTensor<int16_t, 2>(outputDesc, QuantizedVector<int16_t>(qScale,
2379 qOffset, std::vector<float>(
2380 {-0.00396806f, 0.029352f, -0.00279226f, 0.0159977f, -0.00835576f,
2381 -0.0211779f, 0.0283512f, -0.0114597f, 0.00907307f, -0.0244004f,
2382 -0.0152191f, -0.0259063f, 0.00914318f, 0.00415118f, 0.017147f,
2383 0.0134203f, -0.013869f, 0.0287268f, -0.00334693f, 0.00733398f, -0.0287926f,
2384 -0.0186926f, 0.0193662f, -0.0115437f, 0.00422612f, -0.0345232f,
2385 0.00223253f, -0.00957321f, 0.0210624f, 0.013331f, 0.0150954f, 0.02168f})));
2387 return LstmLayerNoCifgWithPeepholeWithProjectionTestImpl<datatype>(
2388 workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, constantDatatype);
2391 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest(
2392 armnn::IWorkloadFactory& workloadFactory,
2393 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2395 const float qScale = 1.0f;
2396 const int32_t qOffset = 0;
2398 const armnn::DataType datatype = armnn::DataType::QuantisedSymm16; // datatype & constants set to QSymm16
2400 armnn::TensorInfo inputDesc({2, 2}, datatype);
2401 boost::multi_array<int16_t , 2> input = MakeTensor<int16_t , 2>(inputDesc, QuantizedVector<int16_t>(qScale,
2402 qOffset, std::vector<float>{2., 3., 3., 4.}));
2404 armnn::TensorInfo outputDesc({2, 4}, datatype);
2405 boost::multi_array<int16_t, 2> expectedOutput = MakeTensor<int16_t, 2>(outputDesc, QuantizedVector<int16_t>(qScale,
2406 qOffset, std::vector<float>({{-0.02973187f, 0.1229473f, 0.20885126f, -0.15358765f,
2407 -0.0185422f, 0.11281417f, 0.24466537f, -0.1826292f}})));
2409 return LstmNoCifgNoPeepholeNoProjectionTestImpl<datatype>(
2410 workloadFactory, memoryManager, input, expectedOutput, qScale, qOffset, datatype);
2414 LayerTestResult<uint8_t, 2> QuantizedLstmTest(
2415 armnn::IWorkloadFactory& workloadFactory,
2416 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2418 armnn::TensorInfo inputDesc({2, 2}, armnn::DataType::QuantisedAsymm8);
2419 boost::multi_array<uint8_t, 2> input = MakeTensor<uint8_t, 2>(inputDesc, std::vector<uint8_t>(
2420 {166, 179, 50, 150}));
2422 armnn::TensorInfo outputDesc({2, 4}, armnn::DataType::QuantisedAsymm8);
2423 boost::multi_array<uint8_t, 2> expectedOutput = MakeTensor<uint8_t, 2>(outputDesc, std::vector<uint8_t>(
2424 {140, 151, 146, 112, 136, 156, 142, 112 }));
2426 return QuantizedLstmTestImpl(workloadFactory, memoryManager, input, expectedOutput);
2429 LayerTestResult<float,3> ConcatTest(
2430 armnn::IWorkloadFactory& workloadFactory,
2431 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2433 unsigned int outputWidth = 3;
2434 unsigned int outputHeight = 6;
2435 unsigned int outputChannels = 3;
2437 unsigned int inputWidth1 = 3;
2438 unsigned int inputHeight1 = 6;
2439 unsigned int inputChannels1 = 2;
2441 unsigned int inputWidth2 = 3;
2442 unsigned int inputHeight2 = 6;
2443 unsigned int inputChannels2 = 1;
2445 // Define the tensor descriptors.
2446 armnn::TensorInfo outputTensorInfo({ outputChannels, outputHeight, outputWidth }, armnn::DataType::Float32);
2447 armnn::TensorInfo inputTensorInfo1({ inputChannels1, inputHeight1, inputWidth1 }, armnn::DataType::Float32);
2448 armnn::TensorInfo inputTensorInfo2({ inputChannels2, inputHeight2, inputWidth2 }, armnn::DataType::Float32);
2450 LayerTestResult<float,3> ret(outputTensorInfo);
2452 ret.outputExpected = MakeTensor<float, 3>(outputTensorInfo, std::vector<float>(
2457 10.0f, 11.0f, 12.0f,
2458 13.0f, 14.0f, 15.0f,
2459 16.0f, 17.0f, 18.0f,
2461 19.0f, 20.0f, 21.0f,
2462 22.0f, 23.0f, 24.0f,
2463 25.0f, 26.0f, 27.0f,
2464 28.0f, 29.0f, 30.0f,
2465 31.0f, 32.0f, 33.0f,
2466 34.0f, 35.0f, 36.0f,
2468 37.0f, 38.0f, 39.0f,
2469 40.0f, 41.0f, 42.0f,
2470 43.0f, 44.0f, 45.0f,
2471 46.0f, 47.0f, 48.0f,
2472 49.0f, 50.0f, 51.0f,
2473 52.0f, 53.0f, 54.0f,
2477 auto input1 = MakeTensor<float, 3>(inputTensorInfo1, std::vector<float>(
2482 10.0f, 11.0f, 12.0f,
2483 13.0f, 14.0f, 15.0f,
2484 16.0f, 17.0f, 18.0f,
2486 19.0f, 20.0f, 21.0f,
2487 22.0f, 23.0f, 24.0f,
2488 25.0f, 26.0f, 27.0f,
2489 28.0f, 29.0f, 30.0f,
2490 31.0f, 32.0f, 33.0f,
2491 34.0f, 35.0f, 36.0f,
2495 auto input2 = MakeTensor<float, 3>(inputTensorInfo2, std::vector<float>(
2497 37.0f, 38.0f, 39.0f,
2498 40.0f, 41.0f, 42.0f,
2499 43.0f, 44.0f, 45.0f,
2500 46.0f, 47.0f, 48.0f,
2501 49.0f, 50.0f, 51.0f,
2502 52.0f, 53.0f, 54.0f,
2506 std::vector<unsigned int> wOrigin1 = {0, 0, 0}; //Extent of the window is defined by size of input[0].
2507 armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
2509 std::vector<unsigned int> wOrigin2 = {2, 0, 0}; //Extent of the window is defined by size of input[1].
2510 armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
2512 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2514 bool subTensorsSupported = workloadFactory.SupportsSubTensors();
2516 std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
2517 subTensorsSupported ?
2518 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
2519 workloadFactory.CreateTensorHandle(inputTensorInfo1);
2521 std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
2522 subTensorsSupported ?
2523 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
2524 workloadFactory.CreateTensorHandle(inputTensorInfo2);
2526 armnn::ConcatQueueDescriptor data;
2527 armnn::WorkloadInfo info;
2528 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2529 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2530 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2532 data.m_ViewOrigins.push_back(window1);
2533 data.m_ViewOrigins.push_back(window2);
2535 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
2537 inputHandle1->Allocate();
2538 inputHandle2->Allocate();
2539 outputHandle->Allocate();
2541 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
2542 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
2544 workload->PostAllocationConfigure();
2545 workload->Execute();
2547 CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
2552 LayerTestResult<float,4> AdditionTest(
2553 armnn::IWorkloadFactory& workloadFactory,
2554 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2556 unsigned int batchSize = 2;
2557 unsigned int channels = 2;
2558 unsigned int height = 2;
2559 unsigned int width = 3;
2561 armnn::TensorInfo inputTensorInfo1, inputTensorInfo2;
2562 armnn::TensorInfo outputTensorInfo;
2564 unsigned int shape[] = {batchSize, channels, height, width};
2566 inputTensorInfo1 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2567 inputTensorInfo2 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2568 outputTensorInfo = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2571 auto input1 = MakeTensor<float, 4>(inputTensorInfo1, std::vector<float>(
2586 auto input2 = MakeTensor<float, 4>(inputTensorInfo2, std::vector<float>(
2601 LayerTestResult<float,4> ret(outputTensorInfo);
2602 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, std::vector<float>(
2617 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
2618 std::unique_ptr<armnn::ITensorHandle> inputHandle2 = workloadFactory.CreateTensorHandle(inputTensorInfo2);
2619 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2621 armnn::AdditionQueueDescriptor data;
2622 armnn::WorkloadInfo info;
2623 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2624 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2625 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2627 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateAddition(data, info);
2629 inputHandle1->Allocate();
2630 inputHandle2->Allocate();
2631 outputHandle->Allocate();
2633 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
2634 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0][0]);
2636 workload->PostAllocationConfigure();
2637 workload->Execute();
2639 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2644 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2645 LayerTestResult<T, 4> AdditionBroadcastTestImpl(
2646 armnn::IWorkloadFactory& workloadFactory,
2647 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2651 armnn::TensorInfo inputTensorInfo1 = armnn::TensorInfo({1, 3, 2, 1}, ArmnnType);
2652 armnn::TensorInfo inputTensorInfo2 = armnn::TensorInfo({1, 1, 2, 3}, ArmnnType);
2653 armnn::TensorInfo outputTensorInfo = armnn::TensorInfo({1, 3, 2, 3}, ArmnnType);
2655 if (armnn::IsQuantizedType<T>())
2657 inputTensorInfo1.SetQuantizationScale(qScale);
2658 inputTensorInfo1.SetQuantizationOffset(qOffset);
2659 inputTensorInfo2.SetQuantizationScale(qScale);
2660 inputTensorInfo2.SetQuantizationOffset(qOffset);
2661 outputTensorInfo.SetQuantizationScale(qScale);
2662 outputTensorInfo.SetQuantizationOffset(qOffset);
2665 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset,
2677 auto input2 = MakeTensor<T, 4>(inputTensorInfo2, QuantizedVector<T>(qScale, qOffset,
2683 LayerTestResult<T,4> ret(outputTensorInfo);
2684 ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset,
2696 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
2697 std::unique_ptr<armnn::ITensorHandle> inputHandle2 = workloadFactory.CreateTensorHandle(inputTensorInfo2);
2698 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2700 armnn::AdditionQueueDescriptor data;
2701 armnn::WorkloadInfo info;
2702 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2703 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2704 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2706 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateAddition(data, info);
2708 inputHandle1->Allocate();
2709 inputHandle2->Allocate();
2710 outputHandle->Allocate();
2712 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
2713 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0][0]);
2715 workload->PostAllocationConfigure();
2716 workload->Execute();
2718 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2723 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2724 LayerTestResult<T, 4> AdditionBroadcast1ElementTestImpl(
2725 armnn::IWorkloadFactory& workloadFactory,
2726 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2730 armnn::TensorInfo inputTensorInfo1 = armnn::TensorInfo({1, 3, 2, 3}, ArmnnType);
2731 armnn::TensorInfo inputTensorInfo2 = armnn::TensorInfo({1, 1, 1, 1}, ArmnnType);
2732 armnn::TensorInfo outputTensorInfo = armnn::TensorInfo({1, 3, 2, 3}, ArmnnType);
2734 if (armnn::IsQuantizedType<T>())
2736 inputTensorInfo1.SetQuantizationScale(qScale);
2737 inputTensorInfo1.SetQuantizationOffset(qOffset);
2738 inputTensorInfo2.SetQuantizationScale(qScale);
2739 inputTensorInfo2.SetQuantizationOffset(qOffset);
2740 outputTensorInfo.SetQuantizationScale(qScale);
2741 outputTensorInfo.SetQuantizationOffset(qOffset);
2744 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset,
2750 12.0f, 13.0f, 14.0f,
2751 15.0f, 16.0f, 17.0f,
2754 auto input2 = MakeTensor<T, 4>(inputTensorInfo2, QuantizedVector<T>(qScale, qOffset,
2759 LayerTestResult<T,4> ret(outputTensorInfo);
2760 ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset,
2766 12.5f, 13.5f, 14.5f,
2767 15.5f, 16.5f, 17.5f,
2770 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
2771 std::unique_ptr<armnn::ITensorHandle> inputHandle2 = workloadFactory.CreateTensorHandle(inputTensorInfo2);
2772 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2774 armnn::AdditionQueueDescriptor data;
2775 armnn::WorkloadInfo info;
2776 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2777 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2778 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2780 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateAddition(data, info);
2782 inputHandle1->Allocate();
2783 inputHandle2->Allocate();
2784 outputHandle->Allocate();
2786 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
2787 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0][0]);
2789 workload->PostAllocationConfigure();
2790 workload->Execute();
2792 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2797 LayerTestResult<float, 4> AdditionBroadcastTest(
2798 armnn::IWorkloadFactory& workloadFactory,
2799 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2801 return AdditionBroadcastTestImpl<armnn::DataType::Float32>(
2802 workloadFactory, memoryManager, 0.0f, 0);
2805 LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(
2806 armnn::IWorkloadFactory& workloadFactory,
2807 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2809 return AdditionBroadcastTestImpl<armnn::DataType::QuantisedAsymm8>(
2810 workloadFactory, memoryManager, 2.f, 0);
2813 LayerTestResult<int16_t, 4> AdditionBroadcastInt16Test(
2814 armnn::IWorkloadFactory& workloadFactory,
2815 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2817 return AdditionBroadcastTestImpl<armnn::DataType::QuantisedSymm16>(
2818 workloadFactory, memoryManager, 2.f, 0);
2821 LayerTestResult<float, 4> AdditionBroadcast1ElementTest(
2822 armnn::IWorkloadFactory& workloadFactory,
2823 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2825 return AdditionBroadcast1ElementTestImpl<armnn::DataType::Float32>(
2826 workloadFactory, memoryManager, 0.0f, 0);
2829 LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(
2830 armnn::IWorkloadFactory& workloadFactory,
2831 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2833 return AdditionBroadcast1ElementTestImpl<armnn::DataType::QuantisedAsymm8>(
2834 workloadFactory, memoryManager, 0.1333333f, 128);
2837 LayerTestResult<int16_t, 4> AdditionBroadcast1ElementInt16Test(
2838 armnn::IWorkloadFactory& workloadFactory,
2839 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2841 return AdditionBroadcast1ElementTestImpl<armnn::DataType::QuantisedSymm16>(
2842 workloadFactory, memoryManager, 0.1333333f, 0);
2845 LayerTestResult<float,4> CompareAdditionTest(
2846 armnn::IWorkloadFactory& workloadFactory,
2847 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2848 armnn::IWorkloadFactory& refWorkloadFactory)
2850 unsigned int batchSize = 4;
2851 unsigned int channels = 1;
2852 unsigned int height = 2;
2853 unsigned int width = 3;
2855 armnn::TensorInfo inputTensorInfo1, inputTensorInfo2;
2856 armnn::TensorInfo outputTensorInfo;
2858 unsigned int shape[] = {batchSize, channels, height, width};
2860 inputTensorInfo1 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2861 inputTensorInfo2 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2862 outputTensorInfo = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
2864 auto input1 = MakeRandomTensor<float, 4>(inputTensorInfo1, 1232);
2865 auto input2 = MakeRandomTensor<float, 4>(inputTensorInfo2, 456);
2867 LayerTestResult<float,4> ret(outputTensorInfo);
2869 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
2870 std::unique_ptr<armnn::ITensorHandle> inputHandle2 = workloadFactory.CreateTensorHandle(inputTensorInfo2);
2871 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2873 std::unique_ptr<armnn::ITensorHandle> inputHandle1Ref = refWorkloadFactory.CreateTensorHandle(inputTensorInfo1);
2874 std::unique_ptr<armnn::ITensorHandle> inputHandle2Ref = refWorkloadFactory.CreateTensorHandle(inputTensorInfo2);
2875 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.CreateTensorHandle(outputTensorInfo);
2877 armnn::AdditionQueueDescriptor data;
2878 armnn::WorkloadInfo info;
2879 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2880 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
2881 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2883 armnn::AdditionQueueDescriptor refData = data;
2884 armnn::WorkloadInfo refInfo = info;
2885 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo1, inputHandle1Ref.get());
2886 SetWorkloadInput(refData, refInfo, 1, inputTensorInfo2, inputHandle2Ref.get());
2887 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
2889 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateAddition(data, info);
2890 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.CreateAddition(refData, refInfo);
2892 inputHandle1->Allocate();
2893 inputHandle2->Allocate();
2894 outputHandle->Allocate();
2895 inputHandle1Ref->Allocate();
2896 inputHandle2Ref->Allocate();
2897 outputHandleRef->Allocate();
2899 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
2900 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0][0]);
2901 CopyDataToITensorHandle(inputHandle1Ref.get(), &input1[0][0][0][0]);
2902 CopyDataToITensorHandle(inputHandle2Ref.get(), &input2[0][0][0][0]);
2904 workload->PostAllocationConfigure();
2905 workload->Execute();
2906 workloadRef->PostAllocationConfigure();
2907 workloadRef->Execute();
2909 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2910 CopyDataFromITensorHandle(&ret.outputExpected[0][0][0][0], outputHandleRef.get());
2916 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2917 LayerTestResult<T, 4> DivisionTestHelper(
2918 armnn::IWorkloadFactory& workloadFactory,
2919 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2920 const unsigned int shape0[4],
2921 const std::vector<T>& values0,
2924 const unsigned int shape1[4],
2925 const std::vector<T> & values1,
2928 const unsigned int outShape[4],
2929 const std::vector<T> & outValues,
2933 armnn::TensorInfo inputTensorInfo0(4, shape0, ArmnnType);
2934 armnn::TensorInfo inputTensorInfo1(4, shape1, ArmnnType);
2935 armnn::TensorInfo outputTensorInfo(4, outShape, ArmnnType);
2937 inputTensorInfo0.SetQuantizationScale(scale0);
2938 inputTensorInfo0.SetQuantizationOffset(offset0);
2940 inputTensorInfo1.SetQuantizationScale(scale1);
2941 inputTensorInfo1.SetQuantizationOffset(offset1);
2943 outputTensorInfo.SetQuantizationScale(outScale);
2944 outputTensorInfo.SetQuantizationOffset(outOffset);
2946 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, values0);
2947 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, values1);
2949 LayerTestResult<T, 4> result(outputTensorInfo);
2950 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outValues);
2952 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
2953 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
2954 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2956 armnn::DivisionQueueDescriptor data;
2957 armnn::WorkloadInfo info;
2958 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
2959 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
2960 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2962 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateDivision(data, info);
2964 inputHandle0->Allocate();
2965 inputHandle1->Allocate();
2966 outputHandle->Allocate();
2968 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
2969 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
2971 workload->PostAllocationConfigure();
2972 workload->Execute();
2974 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2978 } // anonymous namespace
2980 LayerTestResult<float,4> DivisionByZeroTest(
2981 armnn::IWorkloadFactory& workloadFactory,
2982 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2984 const unsigned int width = 2;
2985 const unsigned int height = 2;
2986 const unsigned int channelCount = 2;
2987 const unsigned int batchSize = 2;
2989 unsigned int shape[] = { batchSize, channelCount, height, width };
2991 std::vector<float> input0({
2992 1.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f,
2993 -1.f, -1.f, -1.f, -1.f, 5.f, 5.f, 5.f, 5.f });
2995 std::vector<float> input1({
2996 0.f, 0.f, -0.f, -0.f, 0.f, 0.f, -0.f, -0.f,
2997 0.f, 0.f, -0.f, -0.f, 5.f, 5.f, 5.f, 5.f });
2999 std::vector<float> output({
3000 INFINITY, INFINITY, -INFINITY, -INFINITY, NAN, NAN, -NAN, -NAN,
3001 -INFINITY, -INFINITY, INFINITY, INFINITY, 1, 1, 1, 1 });
3003 return DivisionTestHelper<armnn::DataType::Float32>(workloadFactory,
3005 shape, input0, 1.0f, 0,
3006 shape, input1, 1.0f, 0,
3007 shape, output, 1.0f, 0);
3010 LayerTestResult<float,4> DivisionTest(
3011 armnn::IWorkloadFactory& workloadFactory,
3012 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3014 const unsigned int width = 2;
3015 const unsigned int height = 2;
3016 const unsigned int channelCount = 2;
3017 const unsigned int batchSize = 2;
3019 unsigned int shape[] = { batchSize, channelCount, height, width };
3021 std::vector<float> input0({
3022 2, 2, 2, 2, 3, 3, 3, 3,
3023 4, 4, 4, 4, 5, 5, 5, 5 });
3025 std::vector<float> input1({
3026 1, 1, 1, 1, 2, 2, 2, 2,
3027 4, 4, 4, 4, 4, 4, 4, 4 });
3029 std::vector<float> output({
3030 2, 2, 2, 2, 1.5, 1.5, 1.5, 1.5,
3031 1, 1, 1, 1, 1.25, 1.25, 1.25, 1.25 });
3034 return DivisionTestHelper<armnn::DataType::Float32>(workloadFactory,
3036 shape, input0, 1.0f, 0,
3037 shape, input1, 1.0f, 0,
3038 shape, output, 1.0f, 0);
3041 LayerTestResult<float, 4> DivisionBroadcast1ElementTest(
3042 armnn::IWorkloadFactory& workloadFactory,
3043 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3045 unsigned int shape0[] = { 1, 2, 2, 2 };
3046 std::vector<float> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
3048 unsigned int shape1[] = { 1, 1, 1, 1 };
3049 std::vector<float> input1({ 2 });
3051 std::vector<float> output({ 1, 2, 3, 4, 5, 6, 7, 8});
3054 return DivisionTestHelper<armnn::DataType::Float32>(workloadFactory,
3056 shape0, input0, 1.0f, 0,
3057 shape1, input1, 1.0f, 0,
3058 shape0, output, 1.0f, 0);
3061 LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(
3062 armnn::IWorkloadFactory& workloadFactory,
3063 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3065 unsigned int shape0[] = { 1, 3, 3, 2 };
3066 std::vector<float> input0({
3068 7, 16, 9, 20, 11, 24,
3069 13, 28, 15, 32, 17, 36});
3071 unsigned int shape1[] = { 1, 1, 1, 2 };
3072 std::vector<float> input1({ 1, 2 });
3074 std::vector<float> output({
3076 7, 8, 9, 10, 11, 12,
3077 13, 14, 15, 16, 17, 18});
3079 return DivisionTestHelper<armnn::DataType::Float32>(workloadFactory,
3081 shape0, input0, 1.0f, 0,
3082 shape1, input1, 1.0f, 0,
3083 shape0, output, 1.0f, 0);
3086 LayerTestResult<uint8_t,4> DivisionUint8Test(
3087 armnn::IWorkloadFactory& workloadFactory,
3088 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3090 const unsigned int width = 2;
3091 const unsigned int height = 2;
3092 const unsigned int channelCount = 2;
3093 const unsigned int batchSize = 2;
3095 unsigned int shape[] = { batchSize, channelCount, height, width };
3097 std::vector<uint8_t> input0({2, 2, 2, 2, 3, 3, 3, 3,
3098 4, 4, 4, 4, 5, 5, 5, 5 });
3100 std::vector<uint8_t> input1({1, 1, 1, 1, 2, 2, 2, 2,
3101 4, 4, 4, 4, 4, 4, 4, 4 });
3103 std::vector<uint8_t> output({8, 8, 8, 8, 6, 6, 6, 6,
3104 4, 4, 4, 4, 5, 5, 5, 5});
3107 return DivisionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
3109 shape, input0, 1.0f, 0,
3110 shape, input1, 1.0f, 0,
3111 shape, output, 0.25f, 0);
3114 LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(
3115 armnn::IWorkloadFactory& workloadFactory,
3116 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3118 unsigned int shape0[] = { 1, 2, 2, 2 };
3119 std::vector<uint8_t> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
3121 unsigned int shape1[] = { 1, 1, 1, 1 };
3122 std::vector<uint8_t> input1({ 2 });
3124 std::vector<uint8_t> output({ 1, 2, 3, 4, 5, 6, 7, 8});
3126 return DivisionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
3128 shape0, input0, 1.0f, 0,
3129 shape1, input1, 1.0f, 0,
3130 shape0, output, 1.0f, 0);
3133 LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(
3134 armnn::IWorkloadFactory& workloadFactory,
3135 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3137 unsigned int shape0[] = { 1, 3, 3, 2 };
3138 std::vector<uint8_t> input0({1, 4, 3, 8, 5, 12,
3139 7, 16, 9, 20, 11, 24,
3140 13, 28, 15, 32, 17, 36});
3142 unsigned int shape1[] = { 1, 1, 1, 2 };
3143 std::vector<uint8_t> input1({ 1, 2 });
3145 std::vector<uint8_t> output({1, 2, 3, 4, 5, 6,
3146 7, 8, 9, 10, 11, 12,
3147 13, 14, 15, 16, 17, 18});
3149 return DivisionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
3151 shape0, input0, 1.0f, 0,
3152 shape1, input1, 1.0f, 0,
3153 shape0, output, 1.0f, 0);
3156 LayerTestResult<int16_t,4> DivisionInt16Test(
3157 armnn::IWorkloadFactory& workloadFactory,
3158 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3160 unsigned int shape[] = { 2, 2, 2, 2 };
3162 std::vector<int16_t> input0({2, 2, 2, 2, 3, 3, 3, 3,
3163 4, 4, 4, 4, 5, 5, 5, 5 });
3165 std::vector<int16_t> input1({1, 1, 1, 1, 2, 2, 2, 2,
3166 4, 4, 4, 4, 4, 4, 4, 4 });
3168 std::vector<int16_t> output({8, 8, 8, 8, 6, 6, 6, 6,
3169 4, 4, 4, 4, 5, 5, 5, 5});
3172 return DivisionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
3174 shape, input0, 1.0f, 0,
3175 shape, input1, 1.0f, 0,
3176 shape, output, 0.25f, 0);
3179 LayerTestResult<int16_t, 4> DivisionBroadcast1ElementInt16Test(
3180 armnn::IWorkloadFactory& workloadFactory,
3181 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3183 unsigned int shape0[] = { 1, 2, 2, 2 };
3184 std::vector<int16_t> input0({ 2, 4, 6, 8, 10, 12, 14, 16});
3186 unsigned int shape1[] = { 1, 1, 1, 1 };
3187 std::vector<int16_t> input1({ 2 });
3189 std::vector<int16_t> output({ 1, 2, 3, 4, 5, 6, 7, 8});
3191 return DivisionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
3193 shape0, input0, 1.0f, 0,
3194 shape1, input1, 1.0f, 0,
3195 shape0, output, 1.0f, 0);
3198 LayerTestResult<int16_t, 4> DivisionBroadcast1DVectorInt16Test(
3199 armnn::IWorkloadFactory& workloadFactory,
3200 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3202 unsigned int shape0[] = { 1, 3, 3, 2 };
3203 std::vector<int16_t> input0({1, 4, 3, 8, 5, 12,
3204 7, 16, 9, 20, 11, 24,
3205 13, 28, 15, 32, 17, 36});
3207 unsigned int shape1[] = { 1, 1, 1, 2 };
3208 std::vector<int16_t> input1({ 1, 2 });
3210 std::vector<int16_t> output({1, 2, 3, 4, 5, 6,
3211 7, 8, 9, 10, 11, 12,
3212 13, 14, 15, 16, 17, 18});
3214 return DivisionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
3216 shape0, input0, 1.0f, 0,
3217 shape1, input1, 1.0f, 0,
3218 shape0, output, 1.0f, 0);
3221 template<typename DescriptorType>
3222 std::unique_ptr<armnn::IWorkload> CreateWorkload(
3223 const armnn::IWorkloadFactory& workloadFactory,
3224 const armnn::WorkloadInfo& info,
3225 const DescriptorType& descriptor)
3227 return CreateWorkload(workloadFactory, info, descriptor);
3231 std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::MaximumQueueDescriptor>(
3232 const armnn::IWorkloadFactory& workloadFactory,
3233 const armnn::WorkloadInfo& info,
3234 const armnn::MaximumQueueDescriptor& descriptor)
3236 return workloadFactory.CreateMaximum(descriptor, info);
3240 std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::MinimumQueueDescriptor>(
3241 const armnn::IWorkloadFactory& workloadFactory,
3242 const armnn::WorkloadInfo& info,
3243 const armnn::MinimumQueueDescriptor& descriptor)
3245 return workloadFactory.CreateMinimum(descriptor, info);
3249 std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::EqualQueueDescriptor>(
3250 const armnn::IWorkloadFactory& workloadFactory,
3251 const armnn::WorkloadInfo& info,
3252 const armnn::EqualQueueDescriptor& descriptor)
3254 return workloadFactory.CreateEqual(descriptor, info);
3258 std::unique_ptr<armnn::IWorkload> CreateWorkload<armnn::GreaterQueueDescriptor>(
3259 const armnn::IWorkloadFactory& workloadFactory,
3260 const armnn::WorkloadInfo& info,
3261 const armnn::GreaterQueueDescriptor& descriptor)
3263 return workloadFactory.CreateGreater(descriptor, info);
3268 template <typename Descriptor,
3269 armnn::DataType ArmnnTypeInput,
3270 armnn::DataType ArmnnTypeOutput,
3271 typename TInput = armnn::ResolveType<ArmnnTypeInput>,
3272 typename TOutput = armnn::ResolveType<ArmnnTypeOutput>>
3273 LayerTestResult<TOutput, 4> ElementwiseTestHelper(
3274 armnn::IWorkloadFactory & workloadFactory,
3275 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
3276 const unsigned int shape0[4], std::vector<TInput> values0,
3277 const unsigned int shape1[4], std::vector<TInput> values1,
3278 const unsigned int outShape[4], std::vector<TOutput> outValues,
3279 float qScale = 0.0f, int qOffset = 0)
3281 const uint32_t dimensionCount = 4;
3282 armnn::TensorInfo inputTensorInfo0{dimensionCount, shape0, ArmnnTypeInput};
3283 armnn::TensorInfo inputTensorInfo1{dimensionCount, shape1, ArmnnTypeInput};
3284 armnn::TensorInfo outputTensorInfo{dimensionCount, outShape, ArmnnTypeOutput};
3286 auto input0 = MakeTensor<TInput, 4>(inputTensorInfo0, values0);
3287 auto input1 = MakeTensor<TInput, 4>(inputTensorInfo1, values1);
3289 if (armnn::IsQuantizedType<TInput>())
3291 inputTensorInfo0.SetQuantizationScale(qScale);
3292 inputTensorInfo0.SetQuantizationOffset(qOffset);
3294 inputTensorInfo1.SetQuantizationScale(qScale);
3295 inputTensorInfo1.SetQuantizationOffset(qOffset);
3297 outputTensorInfo.SetQuantizationScale(qScale);
3298 outputTensorInfo.SetQuantizationOffset(qOffset);
3301 LayerTestResult<TOutput,4> ret(outputTensorInfo);
3303 if(ArmnnTypeOutput == armnn::DataType::Boolean)
3305 ret.compareBoolean = true;
3308 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
3309 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
3310 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3313 armnn::WorkloadInfo info;
3314 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
3315 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
3316 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3317 auto workload = CreateWorkload<Descriptor>(workloadFactory, info, data);
3319 inputHandle0->Allocate();
3320 inputHandle1->Allocate();
3321 outputHandle->Allocate();
3323 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
3324 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
3326 workload->PostAllocationConfigure();
3327 ExecuteWorkload(*workload, memoryManager);
3329 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
3331 ret.outputExpected = MakeTensor<TOutput, 4>(outputTensorInfo, outValues);
3335 template <typename Descriptor, armnn::DataType ArmnnT, typename T = armnn::ResolveType<ArmnnT>>
3336 LayerTestResult<T, 4> ElementwiseTestHelper(
3337 armnn::IWorkloadFactory & workloadFactory,
3338 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager,
3339 const unsigned int shape0[4], std::vector<T> values0,
3340 const unsigned int shape1[4], std::vector<T> values1,
3341 const unsigned int outShape[4], std::vector<T> outValues,
3342 float qScale = 0.0f, int qOffset = 0)
3344 return ElementwiseTestHelper<Descriptor, ArmnnT, ArmnnT>
3358 LayerTestResult<uint8_t, 4> EqualSimpleTest(armnn::IWorkloadFactory& workloadFactory,
3359 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3361 const unsigned int width = 2;
3362 const unsigned int height = 2;
3363 const unsigned int channelCount = 2;
3364 const unsigned int batchSize = 2;
3366 unsigned int shape[] = { batchSize, channelCount, height, width };
3368 std::vector<float> input0({ 1, 1, 1, 1, 5, 5, 5, 5,
3369 3, 3, 3, 3, 4, 4, 4, 4 });
3371 std::vector<float> input1({ 1, 1, 1, 1, 3, 3, 3, 3,
3372 5, 5, 5, 5, 4, 4, 4, 4 });
3374 std::vector<uint8_t> output({ 1, 1, 1, 1, 0, 0, 0, 0,
3375 0, 0, 0, 0, 1, 1, 1, 1 });
3377 return ElementwiseTestHelper<armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3388 LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
3389 armnn::IWorkloadFactory& workloadFactory,
3390 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3392 unsigned int shape0[] = { 1, 2, 2, 2 };
3393 std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
3395 unsigned int shape1[] = { 1, 1, 1, 1 };
3396 std::vector<float> input1({ 1 });
3398 std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0, 0, 0});
3400 return ElementwiseTestHelper<armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3411 LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
3412 armnn::IWorkloadFactory& workloadFactory,
3413 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3415 const unsigned int shape0[] = { 1, 2, 2, 3 };
3416 const unsigned int shape1[] = { 1, 1, 1, 3 };
3418 std::vector<float> input0({ 1, 2, 3, 4, 5, 6,
3419 7, 8, 9, 10, 11, 12 });
3421 std::vector<float> input1({ 1, 2, 3});
3423 std::vector<uint8_t> output({ 1, 1, 1, 0, 0, 0,
3424 0, 0, 0, 0, 0, 0 });
3426 return ElementwiseTestHelper<armnn::EqualQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3437 LayerTestResult<uint8_t, 4> EqualUint8Test(
3438 armnn::IWorkloadFactory& workloadFactory,
3439 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3441 unsigned int shape[] = { 2, 2, 2, 2 };
3443 // See dequantized values to the right.
3444 std::vector<uint8_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
3445 3, 3, 3, 3, 7, 7, 7, 7 });
3447 std::vector<uint8_t> input1({ 2, 2, 2, 2, 6, 6, 6, 6,
3448 3, 3, 3, 3, 5, 5, 5, 5 });
3450 std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
3451 1, 1, 1, 1, 0, 0, 0, 0 });
3453 return ElementwiseTestHelper<armnn::EqualQueueDescriptor,
3454 armnn::DataType::QuantisedAsymm8,
3455 armnn::DataType::Boolean>(
3468 LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
3469 armnn::IWorkloadFactory& workloadFactory,
3470 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3472 const unsigned int shape0[] = { 1, 2, 2, 3 };
3473 const unsigned int shape1[] = { 1, 1, 1, 1 };
3475 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3476 7, 8, 9, 10, 11, 12 });
3478 std::vector<uint8_t> input1({ 1 });
3480 std::vector<uint8_t> output({ 1, 0, 0, 0, 0, 0,
3481 0, 0, 0, 0, 0, 0 });
3483 return ElementwiseTestHelper<armnn::EqualQueueDescriptor,
3484 armnn::DataType::QuantisedAsymm8,
3485 armnn::DataType::Boolean>(
3498 LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
3499 armnn::IWorkloadFactory& workloadFactory,
3500 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3502 const unsigned int shape0[] = { 1, 2, 2, 3 };
3503 const unsigned int shape1[] = { 1, 1, 1, 3 };
3505 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3506 7, 8, 9, 10, 11, 12 });
3508 std::vector<uint8_t> input1({ 1, 1, 3});
3510 std::vector<uint8_t> output({ 1, 0, 1, 0, 0, 0,
3511 0, 0, 0, 0, 0, 0 });
3513 return ElementwiseTestHelper<armnn::EqualQueueDescriptor,
3514 armnn::DataType::QuantisedAsymm8,
3515 armnn::DataType::Boolean>(
3528 LayerTestResult<uint8_t, 4> GreaterSimpleTest(armnn::IWorkloadFactory& workloadFactory,
3529 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3531 const unsigned int width = 2;
3532 const unsigned int height = 2;
3533 const unsigned int channelCount = 2;
3534 const unsigned int batchSize = 2;
3536 unsigned int shape[] = { batchSize, channelCount, height, width };
3538 std::vector<float> input0({ 1, 1, 1, 1, 5, 5, 5, 5,
3539 3, 3, 3, 3, 4, 4, 4, 4 });
3541 std::vector<float> input1({ 1, 1, 1, 1, 3, 3, 3, 3,
3542 5, 5, 5, 5, 4, 4, 4, 4 });
3544 std::vector<uint8_t> output({ 0, 0, 0, 0, 1, 1, 1, 1,
3545 0, 0, 0, 0, 0, 0, 0, 0 });
3547 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3558 LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
3559 armnn::IWorkloadFactory& workloadFactory,
3560 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3562 unsigned int shape0[] = { 1, 2, 2, 2 };
3563 std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
3565 unsigned int shape1[] = { 1, 1, 1, 1 };
3566 std::vector<float> input1({ 1 });
3568 std::vector<uint8_t> output({ 0, 1, 1, 1, 1, 1, 1, 1});
3570 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3581 LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
3582 armnn::IWorkloadFactory& workloadFactory,
3583 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3585 const unsigned int shape0[] = { 1, 2, 2, 3 };
3586 const unsigned int shape1[] = { 1, 1, 1, 3 };
3588 std::vector<float> input0({ 1, 2.9f, 2.1f, 4, 5, 6,
3589 7, 8, 9, 10, 11, 12 });
3591 std::vector<float> input1({ 1, 3, 2});
3593 std::vector<uint8_t> output({ 0, 0, 1, 1, 1, 1,
3594 1, 1, 1, 1, 1, 1 });
3596 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor, armnn::DataType::Float32, armnn::DataType::Boolean>(
3607 LayerTestResult<uint8_t, 4> GreaterUint8Test(
3608 armnn::IWorkloadFactory& workloadFactory,
3609 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3611 unsigned int shape[] = { 2, 2, 2, 2 };
3613 // See dequantized values to the right.
3614 std::vector<uint8_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
3615 3, 3, 3, 3, 5, 5, 5, 5 });
3617 std::vector<uint8_t> input1({ 2, 2, 2, 2, 6, 6, 6, 6,
3618 2, 2, 2, 2, 5, 5, 5, 5 });
3620 std::vector<uint8_t> output({ 0, 0, 0, 0, 0, 0, 0, 0,
3621 1, 1, 1, 1, 0, 0, 0, 0 });
3623 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor,
3624 armnn::DataType::QuantisedAsymm8,
3625 armnn::DataType::Boolean>(
3638 LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
3639 armnn::IWorkloadFactory& workloadFactory,
3640 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3642 const unsigned int shape0[] = { 1, 2, 2, 3 };
3643 const unsigned int shape1[] = { 1, 1, 1, 1 };
3645 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3646 7, 8, 9, 10, 11, 12 });
3648 std::vector<uint8_t> input1({ 1 });
3650 std::vector<uint8_t> output({ 0, 1, 1, 1, 1, 1,
3651 1, 1, 1, 1, 1, 1 });
3653 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor,
3654 armnn::DataType::QuantisedAsymm8,
3655 armnn::DataType::Boolean>(
3668 LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
3669 armnn::IWorkloadFactory& workloadFactory,
3670 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3672 const unsigned int shape0[] = { 1, 2, 2, 3 };
3673 const unsigned int shape1[] = { 1, 1, 1, 3 };
3675 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3676 7, 8, 9, 10, 11, 12 });
3678 std::vector<uint8_t> input1({ 1, 1, 3});
3680 std::vector<uint8_t> output({ 0, 1, 0, 1, 1, 1,
3681 1, 1, 1, 1, 1, 1 });
3683 return ElementwiseTestHelper<armnn::GreaterQueueDescriptor,
3684 armnn::DataType::QuantisedAsymm8,
3685 armnn::DataType::Boolean>(
3698 LayerTestResult<float, 4> MaximumSimpleTest(armnn::IWorkloadFactory& workloadFactory,
3699 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3701 const unsigned int width = 2;
3702 const unsigned int height = 2;
3703 const unsigned int channelCount = 2;
3704 const unsigned int batchSize = 2;
3706 unsigned int shape[] = { batchSize, channelCount, height, width };
3708 std::vector<float> input0({ 1, 1, 1, 1, 5, 5, 5, 5,
3709 3, 3, 3, 3, 4, 4, 4, 4 });
3711 std::vector<float> input1({ 2, 2, 2, 2, 3, 3, 3, 3,
3712 4, 4, 4, 4, 5, 5, 5, 5 });
3714 std::vector<float> output({ 2, 2, 2, 2, 5, 5, 5, 5,
3715 4, 4, 4, 4, 5, 5, 5, 5 });
3717 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::Float32>(
3728 LayerTestResult<float, 4> MaximumBroadcast1ElementTest(
3729 armnn::IWorkloadFactory& workloadFactory,
3730 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3732 unsigned int shape0[] = { 1, 2, 2, 2 };
3733 std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
3735 unsigned int shape1[] = { 1, 1, 1, 1 };
3736 std::vector<float> input1({ 2 });
3738 std::vector<float> output({ 2, 2, 3, 4, 5, 6, 7, 8});
3740 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::Float32>(
3751 LayerTestResult<float, 4> MaximumBroadcast1DVectorTest(
3752 armnn::IWorkloadFactory& workloadFactory,
3753 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3755 const unsigned int shape0[] = { 1, 2, 2, 3 };
3756 const unsigned int shape1[] = { 1, 1, 1, 3 };
3758 std::vector<float> input0({ 1, 2, 3, 4, 5, 6,
3759 7, 8, 9, 10, 11, 12 });
3761 std::vector<float> input1({ 1, 2, 3});
3763 std::vector<float> output({ 1, 2, 3, 4, 5, 6,
3764 7, 8, 9, 10, 11, 12 });
3766 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::Float32>(
3777 LayerTestResult<uint8_t, 4> MaximumUint8Test(
3778 armnn::IWorkloadFactory& workloadFactory,
3779 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3781 unsigned int shape[] = { 2, 2, 2, 2 };
3783 // See dequantized values to the right.
3784 std::vector<uint8_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
3785 3, 3, 3, 3, 4, 4, 4, 4 });
3787 std::vector<uint8_t> input1({ 2, 2, 2, 2, 3, 3, 3, 3,
3788 4, 4, 4, 4, 5, 5, 5, 5 });
3790 std::vector<uint8_t> output({ 2, 2, 2, 2, 6, 6, 6, 6,
3791 4, 4, 4, 4, 5, 5, 5, 5 });
3793 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedAsymm8>(
3806 LayerTestResult<uint8_t, 4> MaximumBroadcast1ElementUint8Test(
3807 armnn::IWorkloadFactory& workloadFactory,
3808 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3810 const unsigned int shape0[] = { 1, 2, 2, 3 };
3811 const unsigned int shape1[] = { 1, 1, 1, 1 };
3813 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3814 7, 8, 9, 10, 11, 12 });
3816 std::vector<uint8_t> input1({2});
3818 std::vector<uint8_t> output({ 2, 2, 3, 4, 5, 6,
3819 7, 8, 9, 10, 11, 12 });
3821 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedAsymm8>(
3834 LayerTestResult<uint8_t, 4> MaximumBroadcast1DVectorUint8Test(
3835 armnn::IWorkloadFactory& workloadFactory,
3836 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3838 const unsigned int shape0[] = { 1, 2, 2, 3 };
3839 const unsigned int shape1[] = { 1, 1, 1, 3 };
3841 std::vector<uint8_t> input0({ 1, 2, 3, 4, 5, 6,
3842 7, 8, 9, 10, 11, 12 });
3844 std::vector<uint8_t> input1({ 1, 10, 3});
3846 std::vector<uint8_t> output({ 1, 10, 3, 4, 10, 6,
3847 7, 10, 9, 10, 11, 12 });
3849 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedAsymm8>(
3862 LayerTestResult<int16_t, 4> MaximumInt16Test(
3863 armnn::IWorkloadFactory& workloadFactory,
3864 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3866 unsigned int shape[] = { 2, 2, 2, 2 };
3868 std::vector<int16_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
3869 3, 3, 3, 3, 4, 4, 4, 4 });
3871 std::vector<int16_t> input1({ 2, 2, 2, 2, 3, 3, 3, 3,
3872 4, 4, 4, 4, 5, 5, 5, 5 });
3874 std::vector<int16_t> output({ 2, 2, 2, 2, 6, 6, 6, 6,
3875 4, 4, 4, 4, 5, 5, 5, 5 });
3877 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
3890 LayerTestResult<int16_t, 4> MaximumBroadcast1ElementInt16Test(
3891 armnn::IWorkloadFactory& workloadFactory,
3892 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3894 const unsigned int shape0[] = { 1, 2, 2, 3 };
3895 const unsigned int shape1[] = { 1, 1, 1, 1 };
3897 std::vector<int16_t> input0({ 1, 2, 3, 4, 5, 6,
3898 7, 8, 9, 10, 11, 12 });
3900 std::vector<int16_t> input1({2});
3902 std::vector<int16_t> output({ 2, 2, 3, 4, 5, 6,
3903 7, 8, 9, 10, 11, 12 });
3905 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
3918 LayerTestResult<int16_t, 4> MaximumBroadcast1DVectorInt16Test(
3919 armnn::IWorkloadFactory& workloadFactory,
3920 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3922 const unsigned int shape0[] = { 1, 2, 2, 3 };
3923 const unsigned int shape1[] = { 1, 1, 1, 3 };
3925 std::vector<int16_t> input0({ 1, 2, 3, 4, 5, 6,
3926 7, 8, 9, 10, 11, 12 });
3928 std::vector<int16_t> input1({ 1, 10, 3});
3930 std::vector<int16_t> output({ 1, 10, 3, 4, 10, 6,
3931 7, 10, 9, 10, 11, 12 });
3933 return ElementwiseTestHelper<armnn::MaximumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
3946 LayerTestResult<float, 4> MinimumBroadcast1ElementTest1(
3947 armnn::IWorkloadFactory& workloadFactory,
3948 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3950 unsigned int shape0[] = { 1, 2, 2, 2 };
3951 std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
3953 unsigned int shape1[] = { 1, 1, 1, 1 };
3954 std::vector<float> input1({ 2 });
3956 std::vector<float> output({ 1, 2, 2, 2, 2, 2, 2, 2});
3958 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::Float32>(
3970 LayerTestResult<float, 4> MinimumBroadcast1ElementTest2(
3971 armnn::IWorkloadFactory& workloadFactory,
3972 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3974 unsigned int shape0[] = { 1, 2, 2, 2 };
3975 std::vector<float> input0({ 1, 6, 3, 2, 8, 9, 1, 10});
3977 unsigned int shape1[] = { 1, 1, 1, 1 };
3978 std::vector<float> input1({ 5 });
3980 std::vector<float> output({ 1, 5, 3, 2, 5, 5, 1, 5});
3982 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::Float32>(
3993 LayerTestResult<uint8_t, 4> MinimumBroadcast1DVectorUint8Test(
3994 armnn::IWorkloadFactory & workloadFactory,
3995 const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager)
3997 const unsigned int shape0[] = { 1, 2, 2, 3 };
3998 const unsigned int shape1[] = { 1, 1, 1, 3 };
4000 std::vector<uint8_t> input0({ 1, 2, 3, 3, 2, 1,
4001 7, 1, 2, 3, 4, 5 });
4003 std::vector<uint8_t> input1({ 1, 2, 3});
4005 std::vector<uint8_t> output({ 1, 2, 3, 1, 2, 1,
4006 1, 1, 2, 1, 2, 3 });
4008 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::QuantisedAsymm8>(
4021 LayerTestResult<int16_t, 4> MinimumInt16Test(
4022 armnn::IWorkloadFactory& workloadFactory,
4023 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4025 unsigned int shape[] = { 2, 2, 2, 2 };
4027 std::vector<int16_t> input0({ 1, 1, 1, 1, 6, 6, 6, 6,
4028 3, 3, 3, 3, 4, 4, 4, 4 });
4030 std::vector<int16_t> input1({ 2, 2, 2, 2, 3, 3, 3, 3,
4031 4, 4, 4, 4, 5, 5, 5, 5 });
4033 std::vector<int16_t> output({ 1, 1, 1, 1, 3, 3, 3, 3,
4034 3, 3, 3, 3, 4, 4, 4, 4 });
4036 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
4049 LayerTestResult<int16_t, 4> MinimumBroadcast1ElementInt16Test(
4050 armnn::IWorkloadFactory& workloadFactory,
4051 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4053 const unsigned int shape0[] = { 1, 2, 2, 3 };
4054 const unsigned int shape1[] = { 1, 1, 1, 1 };
4056 std::vector<int16_t> input0({ 1, 2, 3, 4, 5, 6,
4057 7, 8, 9, 10, 11, 12 });
4059 std::vector<int16_t> input1({2});
4061 std::vector<int16_t> output({ 1, 2, 2, 2, 2, 2,
4062 2, 2, 2, 2, 2, 2 });
4064 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
4077 LayerTestResult<int16_t, 4> MinimumBroadcast1DVectorInt16Test(
4078 armnn::IWorkloadFactory& workloadFactory,
4079 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4081 const unsigned int shape0[] = { 1, 2, 2, 3 };
4082 const unsigned int shape1[] = { 1, 1, 1, 3 };
4084 std::vector<int16_t> input0({ 1, 2, 3, 4, 5, 6,
4085 7, 8, 9, 10, 11, 12 });
4087 std::vector<int16_t> input1({ 1, 10, 3});
4089 std::vector<int16_t> output({ 1, 2, 3, 1, 5, 3,
4090 1, 8, 3, 1, 10, 3 });
4092 return ElementwiseTestHelper<armnn::MinimumQueueDescriptor, armnn::DataType::QuantisedSymm16>(
4106 LayerTestResult<float,4> MultiplicationTestHelper(
4107 armnn::IWorkloadFactory& workloadFactory,
4108 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4109 const unsigned int shape0[4],
4110 const std::vector<float> & values0,
4111 const unsigned int shape1[4],
4112 const std::vector<float> & values1,
4113 const unsigned int outShape[4],
4114 const std::vector<float> & outValues)
4116 const uint32_t dimensionCount = 4;
4117 armnn::TensorInfo inputTensorInfo0{dimensionCount, shape0, armnn::DataType::Float32};
4118 armnn::TensorInfo inputTensorInfo1{dimensionCount, shape1, armnn::DataType::Float32};
4119 armnn::TensorInfo outputTensorInfo{dimensionCount, outShape, armnn::DataType::Float32};
4121 auto input0 = MakeTensor<float, 4>(inputTensorInfo0, values0);
4122 auto input1 = MakeTensor<float, 4>(inputTensorInfo1, values1);
4124 LayerTestResult<float,4> ret(outputTensorInfo);
4126 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
4127 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
4128 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4130 armnn::MultiplicationQueueDescriptor data;
4131 armnn::WorkloadInfo info;
4132 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
4133 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
4134 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
4136 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateMultiplication(data, info);
4138 inputHandle0->Allocate();
4139 inputHandle1->Allocate();
4140 outputHandle->Allocate();
4142 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
4143 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
4145 workload->PostAllocationConfigure();
4146 workload->Execute();
4148 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
4150 ret.outputExpected = MakeTensor<float, 4>(outputTensorInfo, outValues);
4153 } // anonymous namespace
4156 LayerTestResult<float,4> MultiplicationTest(
4157 armnn::IWorkloadFactory& workloadFactory,
4158 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4160 const unsigned int width = 2;
4161 const unsigned int height = 2;
4162 const unsigned int channelCount = 2;
4163 const unsigned int batchSize = 2;
4165 unsigned int shape[] = { batchSize, channelCount, height, width };
4167 std::vector<float> input0({
4168 1, 1, 1, 1, 2, 2, 2, 2,
4169 3, 3, 3, 3, 4, 4, 4, 4 });
4171 std::vector<float> input1({
4172 2, 2, 2, 2, 3, 3, 3, 3,
4173 4, 4, 4, 4, 5, 5, 5, 5 });
4175 std::vector<float> output({
4176 2, 2, 2, 2, 6, 6, 6, 6,
4177 12, 12, 12, 12, 20, 20, 20, 20 });
4179 return MultiplicationTestHelper(workloadFactory,
4189 LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(
4190 armnn::IWorkloadFactory& workloadFactory,
4191 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4193 unsigned int shape0[] = { 1, 2, 2, 2 };
4194 std::vector<float> input0({ 1, 2, 3, 4, 5, 6, 7, 8});
4196 unsigned int shape1[] = { 1, 1, 1, 1 };
4197 std::vector<float> input1({ 2 });
4199 std::vector<float> output({ 2, 4, 6, 8, 10, 12, 14, 16});
4201 return MultiplicationTestHelper(workloadFactory,
4211 LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(
4212 armnn::IWorkloadFactory& workloadFactory,
4213 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4215 unsigned int shape0[] = { 1, 3, 3, 2 };
4216 std::vector<float> input0({
4218 7, 8, 9, 10, 11, 12,
4219 13, 14, 15, 16, 17, 18});
4221 unsigned int shape1[] = { 1, 1, 1, 2 };
4222 std::vector<float> input1({ 1, 2 });
4224 std::vector<float> output({
4226 7, 16, 9, 20, 11, 24,
4227 13, 28, 15, 32, 17, 36});
4229 return MultiplicationTestHelper(workloadFactory,
4239 LayerTestResult<float,4> CompareMultiplicationTest(
4240 armnn::IWorkloadFactory& workloadFactory,
4241 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4242 armnn::IWorkloadFactory& refWorkloadFactory)
4244 const unsigned int width = 16;
4245 const unsigned int height = 32;
4246 const unsigned int channelCount = 2;
4247 const unsigned int batchSize = 5;
4249 armnn::TensorInfo inputTensorInfo0;
4250 armnn::TensorInfo inputTensorInfo1;
4251 armnn::TensorInfo outputTensorInfo;
4253 constexpr unsigned int shape[] = { batchSize, channelCount, height, width };
4255 inputTensorInfo0 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
4256 inputTensorInfo1 = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
4257 outputTensorInfo = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
4259 LayerTestResult<float,4> comparisonResult(outputTensorInfo);
4261 auto input0 = MakeRandomTensor<float, 4>(inputTensorInfo0, 803506992);
4262 auto input1 = MakeRandomTensor<float, 4>(inputTensorInfo1, 54902257);
4264 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
4265 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
4266 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4268 std::unique_ptr<armnn::ITensorHandle> inputHandle0Ref = refWorkloadFactory.CreateTensorHandle(inputTensorInfo0);
4269 std::unique_ptr<armnn::ITensorHandle> inputHandle1Ref = refWorkloadFactory.CreateTensorHandle(inputTensorInfo1);
4270 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.CreateTensorHandle(outputTensorInfo);
4272 armnn::MultiplicationQueueDescriptor data;
4273 armnn::WorkloadInfo info;
4274 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
4275 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
4276 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
4278 armnn::MultiplicationQueueDescriptor refData = data;
4279 armnn::WorkloadInfo refInfo = info;
4280 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo0, inputHandle0Ref.get());
4281 SetWorkloadInput(refData, refInfo, 1, inputTensorInfo1, inputHandle1Ref.get());
4282 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
4284 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateMultiplication(data, info);
4285 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.CreateMultiplication(refData, refInfo);
4287 inputHandle0->Allocate();
4288 inputHandle1->Allocate();
4289 outputHandle->Allocate();
4290 inputHandle0Ref->Allocate();
4291 inputHandle1Ref->Allocate();
4292 outputHandleRef->Allocate();
4294 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
4295 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
4296 CopyDataToITensorHandle(inputHandle0Ref.get(), &input0[0][0][0][0]);
4297 CopyDataToITensorHandle(inputHandle1Ref.get(), &input1[0][0][0][0]);
4299 workload->PostAllocationConfigure();
4300 workload->Execute();
4301 workloadRef->PostAllocationConfigure();
4302 workloadRef->Execute();
4303 CopyDataFromITensorHandle(&comparisonResult.output[0][0][0][0], outputHandle.get());
4304 CopyDataFromITensorHandle(&comparisonResult.outputExpected[0][0][0][0], outputHandleRef.get());
4306 return comparisonResult;
4309 LayerTestResult<float,4> CompareBatchNormTest(
4310 armnn::IWorkloadFactory& workloadFactory,
4311 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4312 armnn::IWorkloadFactory& refWorkloadFactory)
4314 const unsigned int width = 2;
4315 const unsigned int height = 3;
4316 const unsigned int channels = 5;
4317 const unsigned int batchSize = 3;
4319 armnn::TensorInfo inputTensorInfo;
4320 armnn::TensorInfo outputTensorInfo;
4321 armnn::TensorInfo tensorInfo;
4323 constexpr unsigned int shape[] = {batchSize, channels, height, width};
4324 constexpr unsigned int tensorShape[] = {channels};
4326 inputTensorInfo = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
4327 outputTensorInfo = armnn::TensorInfo(4, shape, armnn::DataType::Float32);
4328 tensorInfo = armnn::TensorInfo(1, tensorShape, armnn::DataType::Float32);
4330 auto input = MakeRandomTensor<float, 4>(inputTensorInfo, 21312);
4332 auto mean = MakeRandomTensor<float, 1>(tensorInfo, 123);
4333 auto variance = MakeRandomTensor<float, 1>(tensorInfo, 234, 0.0f);
4334 auto beta = MakeRandomTensor<float, 1>(tensorInfo, 123);
4335 auto gamma = MakeRandomTensor<float, 1>(tensorInfo, 345);
4337 LayerTestResult<float,4> ret(outputTensorInfo);
4339 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
4340 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4342 std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refWorkloadFactory.CreateTensorHandle(inputTensorInfo);
4343 std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refWorkloadFactory.CreateTensorHandle(outputTensorInfo);
4345 armnn::BatchNormalizationQueueDescriptor data;
4346 armnn::WorkloadInfo info;
4347 armnn::ScopedCpuTensorHandle meanTensor(tensorInfo);
4348 armnn::ScopedCpuTensorHandle varianceTensor(tensorInfo);
4349 armnn::ScopedCpuTensorHandle betaTensor(tensorInfo);
4350 armnn::ScopedCpuTensorHandle gammaTensor(tensorInfo);
4352 AllocateAndCopyDataToITensorHandle(&meanTensor, &mean[0]);
4353 AllocateAndCopyDataToITensorHandle(&varianceTensor, &variance[0]);
4354 AllocateAndCopyDataToITensorHandle(&betaTensor, &beta[0]);
4355 AllocateAndCopyDataToITensorHandle(&gammaTensor, &gamma[0]);
4357 AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
4358 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
4359 data.m_Mean = &meanTensor;
4360 data.m_Variance = &varianceTensor;
4361 data.m_Beta = &betaTensor;
4362 data.m_Gamma = &gammaTensor;
4363 data.m_Parameters.m_Eps = 0.01f;
4365 armnn::BatchNormalizationQueueDescriptor refData = data;
4366 armnn::WorkloadInfo refInfo = info;
4367 SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
4368 SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
4370 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateBatchNormalization(data, info);
4371 std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.CreateBatchNormalization(refData, refInfo);
4373 inputHandle->Allocate();
4374 outputHandle->Allocate();
4375 inputHandleRef->Allocate();
4376 outputHandleRef->Allocate();
4378 CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
4379 CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0][0][0]);
4381 workload->PostAllocationConfigure();
4382 workload->Execute();
4383 workloadRef->PostAllocationConfigure();
4384 workloadRef->Execute();
4386 CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
4387 CopyDataFromITensorHandle(&ret.outputExpected[0][0][0][0], outputHandleRef.get());
4392 template<typename T>
4393 void PermuteTensorData(
4394 armnn::IWorkloadFactory& workloadFactory,
4395 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4396 const armnn::PermutationVector& mappings,
4397 armnn::TensorInfo & inputTensorInfo,
4398 const T * inputData,
4399 std::vector<T>& outputData)
4401 BOOST_ASSERT_MSG(inputData != nullptr, "inputData must not be null");
4402 if (inputData == nullptr)
4404 // Nullptr is an error in the test. By returning without doing the concatenation
4405 // I expect the caller to fail the test. It still makes sense to report this as
4406 // an assert for Debug builds.
4410 armnn::TensorInfo outputTensorInfo = armnnUtils::Permuted(inputTensorInfo, mappings);
4412 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
4413 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4415 armnn::PermuteQueueDescriptor queueDescriptor;
4416 queueDescriptor.m_Parameters = armnn::PermuteDescriptor{mappings};
4417 armnn::WorkloadInfo workloadInfo;
4418 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfo, inputHandle.get());
4419 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
4421 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePermute(queueDescriptor, workloadInfo);
4423 inputHandle->Allocate();
4424 outputHandle->Allocate();
4426 CopyDataToITensorHandle(inputHandle.get(), inputData);
4428 workload->PostAllocationConfigure();
4429 workload->Execute();
4431 outputData.resize(outputTensorInfo.GetNumElements());
4432 CopyDataFromITensorHandle(&outputData[0], outputHandle.get());
4433 inputTensorInfo = outputTensorInfo;
4436 armnn::OriginsDescriptor CreateDescriptorForConcatenation(
4437 const std::vector<armnn::TensorInfo> & inputTensorInfos,
4438 unsigned int concatDim)
4440 std::vector<armnn::TensorShape> shapes;
4441 shapes.reserve(inputTensorInfos.size());
4442 for (const armnn::TensorInfo& it: inputTensorInfos)
4444 shapes.push_back(it.GetShape());
4447 return armnn::CreateDescriptorForConcatenation(shapes.begin(),
4453 // Concatenation is only supported for N and C dimensions for NCHW and the inner most dimension
4454 // In case of <4 dimensions we need to make sure that the concat dimensions are at least
4455 // the 3rd slowest iterating one or the inner most dimension.
4458 bool NeedPermuteForConcat(
4459 const std::vector<armnn::TensorInfo> & inputTensorInfos,
4460 unsigned int concatDim)
4462 // See note above. Additionally we expect the input shapes to have the
4463 // same number of dimensions.
4464 unsigned int nDimensions = 0;
4466 // Determine the number of dimensions as well as sanity check them
4467 // agains test implementation issues.
4468 for (auto && tensorInfo : inputTensorInfos)
4472 nDimensions = tensorInfo.GetShape().GetNumDimensions();
4476 BOOST_ASSERT_MSG(nDimensions == tensorInfo.GetShape().GetNumDimensions(),
4477 "Input shapes must have the same number of dimensions");
4481 return (nDimensions < 3 || (nDimensions == 3 && (nDimensions-concatDim) < 3 && (nDimensions-concatDim) != 1));
4484 armnn::TensorShape ExpandTensorShapeTo3dForPermute(const armnn::TensorShape & inputShape)
4486 unsigned int numDims = inputShape.GetNumDimensions();
4489 // Nothing to do if the inputShape has at least 3 dimensions.
4493 std::vector<unsigned int> newDims(size_t(3), 1u);
4494 unsigned int expandedBy = 3 - numDims;
4495 for (unsigned int i=0; i<numDims; ++i)
4497 newDims[expandedBy+i] = inputShape[i];
4499 return armnn::TensorShape(3u, &newDims[0]);
4502 void Generate3dPermuteVectorForConcat(
4503 unsigned int numDimensions,
4504 unsigned int & concatDim,
4505 std::pair<armnn::PermutationVector, armnn::PermutationVector> & permutations)
4507 BOOST_ASSERT_MSG(numDimensions <= 3,
4508 "Only dimensions 1,2 and 3 are supported by this helper");
4509 unsigned int expandedBy = 3 - numDimensions;
4510 unsigned int expandedConcatAxis = concatDim + expandedBy;
4512 if (expandedConcatAxis == 2)
4515 armnn::PermutationVector forwardPermutation({1, 2, 0});
4516 armnn::PermutationVector reversePermutation({2, 0, 1});
4517 permutations = std::make_pair(forwardPermutation, reversePermutation);
4519 else if (expandedConcatAxis == 1)
4522 armnn::PermutationVector forwardPermutation({2, 0, 1});
4523 armnn::PermutationVector reversePermutation({1, 2, 0});
4524 permutations = std::make_pair(forwardPermutation, reversePermutation);
4528 BOOST_ASSERT(expandedConcatAxis == 0);
4534 // Permute the input tensors so we can do a supported concatenation.
4535 // Also treat lower than 3d tensors as 3d by adding dummy 1 dimensions
4536 // at the front. Finally this function tells what the output shape
4537 // of the permuted concatenated tensor is going to be.
4539 template <typename T>
4540 void PermuteInputsForConcat(
4541 armnn::IWorkloadFactory& workloadFactory,
4542 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4543 std::vector<armnn::TensorInfo> & inputTensorInfos,
4544 std::vector<T *> & inputData,
4545 std::vector<std::vector<T>> & inputDataStorage,
4546 armnn::PermutationVector & permuteVector,
4547 unsigned int & concatDim,
4548 armnn::TensorInfo & outputTensorInfo)
4550 BOOST_ASSERT_MSG(inputTensorInfos.size() > 1,
4551 "Expecting more than one tensor to be concatenated here");
4553 unsigned int numDims = 0;
4554 unsigned int nthInput = 0;
4555 const armnn::PermutationVector identity({0, 1, 2});
4557 std::pair<armnn::PermutationVector, armnn::PermutationVector> permutations =
4558 std::make_pair(identity, identity);
4560 inputDataStorage.resize(inputData.size());
4562 for (auto && tensorInfo : inputTensorInfos)
4566 numDims = tensorInfo.GetShape().GetNumDimensions();
4567 Generate3dPermuteVectorForConcat(numDims, concatDim, permutations);
4569 // Store the reverese permutation.
4570 permuteVector = permutations.second;
4571 BOOST_ASSERT_MSG(!permuteVector.IsEqual(identity),
4572 "Test logic error, we don't need permutation, so we shouldn't arrive here");
4576 BOOST_ASSERT_MSG(numDims == tensorInfo.GetShape().GetNumDimensions(),
4577 "All inputs must have the same number of dimensions");
4580 armnn::TensorInfo newTensorInfo = tensorInfo;
4581 newTensorInfo.SetShape(ExpandTensorShapeTo3dForPermute(tensorInfo.GetShape()));
4583 PermuteTensorData<T>(workloadFactory,
4587 inputData[nthInput],
4588 inputDataStorage[nthInput]);
4590 inputData[nthInput] = inputDataStorage[nthInput].data();
4591 inputTensorInfos[nthInput] = newTensorInfo;
4596 outputTensorInfo.SetShape(
4597 armnnUtils::Permuted(
4598 ExpandTensorShapeTo3dForPermute(outputTensorInfo.GetShape()),
4599 permutations.first));
4604 // This is the pair of PermuteInputsForConcat(...) which permutes back
4605 // the output of the concatenation so we can check it against an expected
4608 template <typename T>
4609 void PermuteOutputForConcat(
4610 armnn::IWorkloadFactory& workloadFactory,
4611 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4612 const armnn::TensorInfo & tensorInfo,
4613 const armnn::PermutationVector & permuteVector,
4614 std::unique_ptr<armnn::ITensorHandle> && inputDataHandle,
4617 BOOST_ASSERT_MSG(data != nullptr, "data must not be null");
4618 if (data == nullptr)
4620 // Nullptr is an error in the test. By returning without doing the permutation
4621 // I expect the caller to fail the test. It still makes sense to report this as
4622 // an assert for Debug builds.
4626 armnn::TensorInfo resultTensorInfo = tensorInfo;
4627 std::vector<T> inputData(tensorInfo.GetNumElements());
4628 std::vector<T> outputData;
4630 CopyDataFromITensorHandle(&inputData[0], inputDataHandle.get());
4632 PermuteTensorData<T>(workloadFactory,
4639 ::memcpy(data, &outputData[0], sizeof(T)*outputData.size());
4642 template <typename T>
4644 armnn::IWorkloadFactory& workloadFactory,
4645 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4646 std::initializer_list<const armnn::TensorInfo> inputTensorInfosOrig,
4647 std::initializer_list<T *> inputsOrig,
4648 const armnn::TensorInfo& outputTensorInfoOrig,
4650 unsigned int concatDim,
4653 BOOST_ASSERT_MSG(output != nullptr, "output must not be null");
4654 if (output == nullptr)
4656 // Nullptr is an error in the test. By returning without doing the permutation
4657 // I expect the caller to fail the test. It still makes sense to report this as
4658 // an assert for Debug builds.
4662 // Saves a copy of the parameters which we might need to change.
4663 std::vector<armnn::TensorInfo> inputTensorInfos(inputTensorInfosOrig.begin(), inputTensorInfosOrig.end());
4664 std::vector<T *> inputs = inputsOrig;
4665 armnn::TensorInfo outputTensorInfo = outputTensorInfoOrig;
4667 armnn::PermutationVector permuteVector{0, 1, 2};
4669 // Holds and automatically releases memory for the reshaped input data.
4670 std::vector<std::vector<T>> tmpInputDataStorage;
4672 const size_t inputCount = inputTensorInfos.size();
4674 bool needPermuteForConcat = NeedPermuteForConcat(inputTensorInfos, concatDim);
4676 if (needPermuteForConcat)
4679 // We need to permute the inputs, because concatenation along
4680 // the requested axis is not supported.
4682 PermuteInputsForConcat<T>(workloadFactory,
4686 tmpInputDataStorage,
4692 armnn::WorkloadInfo workloadInfo;
4694 std::vector<std::unique_ptr<armnn::ITensorHandle>> inputHandles;
4695 inputHandles.reserve(inputCount);
4697 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4699 armnn::ConcatQueueDescriptor queueDescriptor;
4700 armnn::OriginsDescriptor viewsDescriptor = CreateDescriptorForConcatenation(inputTensorInfos, concatDim);
4701 queueDescriptor.m_Parameters = viewsDescriptor;
4705 queueDescriptor.m_ViewOrigins.reserve(viewsDescriptor.GetNumViews());
4706 for (unsigned int i = 0; i < viewsDescriptor.GetNumViews(); ++i)
4708 queueDescriptor.m_ViewOrigins.emplace_back(std::vector<unsigned int>(viewsDescriptor.GetViewOrigin(i),
4709 viewsDescriptor.GetViewOrigin(i) + viewsDescriptor.GetNumDimensions()));
4712 outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
4714 const bool subTensorsSupported = workloadFactory.SupportsSubTensors();
4715 for (unsigned int i = 0; i < inputCount; ++i)
4717 const armnn::TensorInfo& inputTensorInfo = inputTensorInfos[i];
4718 std::unique_ptr<armnn::ITensorHandle> inputHandle =
4719 subTensorsSupported ?
4720 workloadFactory.CreateSubTensorHandle(*outputHandle,
4721 inputTensorInfo.GetShape(),
4722 queueDescriptor.m_ViewOrigins[i].m_Origin.data()) :
4723 workloadFactory.CreateTensorHandle(inputTensorInfo);
4725 inputHandles.emplace_back(std::move(inputHandle));
4731 for (unsigned int i = 0; i < inputCount; ++i)
4733 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfos[i]);
4734 inputHandles.emplace_back(std::move(inputHandle));
4738 for (unsigned int i = 0; i < inputCount; ++i)
4740 AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfos[i], inputHandles[i].get());
4743 AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
4745 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(queueDescriptor, workloadInfo);
4747 for (auto& inputHandle : inputHandles)
4749 inputHandle->Allocate();
4752 outputHandle->Allocate();
4754 unsigned int nextInputId = 0;
4755 for (auto& inputHandle : inputHandles)
4757 CopyDataToITensorHandle(inputHandle.get(), inputs[nextInputId]);
4761 workload->PostAllocationConfigure();
4762 workload->Execute();
4764 if (needPermuteForConcat)
4766 PermuteOutputForConcat<T>(workloadFactory,
4770 std::move(outputHandle),
4775 CopyDataFromITensorHandle(output, outputHandle.get());
4779 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4780 LayerTestResult<T, 1> Concatenation1dTestImpl(
4781 armnn::IWorkloadFactory& workloadFactory,
4782 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4786 armnn::TensorInfo inputTensorInfo({ 3 }, ArmnnType, qScale, qOffset);
4788 auto input0 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, { 1.0f, 2.0f, 3.0f }));
4789 auto input1 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, { 4.0f, 5.0f, 6.0f }));
4790 auto input2 = MakeTensor<T, 1>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, { 7.0f, 8.0f, 9.0f }));
4792 armnn::TensorInfo outputTensorInfo({ 9 }, ArmnnType, qScale, qOffset);
4794 LayerTestResult<T, 1> result(outputTensorInfo);
4796 std::vector<T> output;
4797 output.resize(outputTensorInfo.GetNumElements());
4798 Concatenate<T>(workloadFactory, memoryManager,
4799 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
4800 { input0.data(), input1.data(), input2.data() },
4806 result.output = MakeTensor<T, 1>(outputTensorInfo, output);
4807 result.outputExpected = MakeTensor<T, 1>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4808 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f
4814 LayerTestResult<float, 1> Concatenation1dTest(
4815 armnn::IWorkloadFactory& workloadFactory,
4816 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4818 return Concatenation1dTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
4821 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4822 LayerTestResult<T, 2> Concatenation2dTestImpl(
4823 armnn::IWorkloadFactory& workloadFactory,
4824 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4825 const armnn::TensorInfo& outputTensorInfo,
4826 unsigned int dimension,
4828 const int32_t qOffset)
4830 armnn::TensorInfo inputTensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
4832 auto input0 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4837 10.0f, 11.0f, 12.0f,
4840 auto input1 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4845 13.0f, 14.0f, 15.0f,
4848 auto input2 = MakeTensor<T, 2>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4853 16.0f, 17.0f, 18.0f,
4856 LayerTestResult<T, 2> result(outputTensorInfo);
4858 std::vector<T> output;
4859 output.resize(outputTensorInfo.GetNumElements());
4860 Concatenate<T>(workloadFactory, memoryManager,
4861 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
4862 { input0.data(), input1.data(), input2.data() },
4868 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
4872 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4873 LayerTestResult<T, 2> Concatenation2dDim0TestImpl(
4874 armnn::IWorkloadFactory& workloadFactory,
4875 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4879 armnn::TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
4881 LayerTestResult<T, 2> result = Concatenation2dTestImpl<ArmnnType>(
4882 workloadFactory, memoryManager, outputTensorInfo, 0, qScale, qOffset);
4884 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4889 10.0f, 11.0f, 12.0f,
4895 13.0f, 14.0f, 15.0f,
4901 16.0f, 17.0f, 18.0f,
4907 LayerTestResult<float, 2> Concatenation2dDim0Test(
4908 armnn::IWorkloadFactory& workloadFactory,
4909 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4911 return Concatenation2dDim0TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
4914 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4915 LayerTestResult<T, 2> Concatenation2dDim1TestImpl(
4916 armnn::IWorkloadFactory& workloadFactory,
4917 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4921 armnn::TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
4923 LayerTestResult<T, 2> result = Concatenation2dTestImpl<ArmnnType>(
4924 workloadFactory, memoryManager, outputTensorInfo, 1, qScale, qOffset);
4926 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4928 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
4931 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f
4937 LayerTestResult<float, 2> Concatenation2dDim1Test(
4938 armnn::IWorkloadFactory& workloadFactory,
4939 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4941 return Concatenation2dDim1TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
4944 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4945 LayerTestResult<T, 2> Concatenation2dDim0DiffInputDimsTestImpl(
4946 armnn::IWorkloadFactory& workloadFactory,
4947 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
4951 armnn::TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
4952 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(qScale, qOffset, {
4957 10.0f, 11.0f, 12.0f,
4960 armnn::TensorInfo input1TensorInfo({ 3, 3 }, ArmnnType, qScale, qOffset);
4961 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(qScale, qOffset, {
4966 13.0f, 14.0f, 15.0f,
4972 armnn::TensorInfo input2TensorInfo({ 1, 3 }, ArmnnType, qScale, qOffset);
4973 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(qScale, qOffset, {
4975 16.0f, 17.0f, 18.0f,
4978 armnn::TensorInfo outputTensorInfo({ 6, 3 }, ArmnnType, qScale, qOffset);
4979 LayerTestResult<T, 2> result(outputTensorInfo);
4981 std::vector<T> output;
4982 output.resize(outputTensorInfo.GetNumElements());
4983 Concatenate<T>(workloadFactory, memoryManager,
4984 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
4985 { input0.data(), input1.data(), input2.data() },
4991 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
4992 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
4997 10.0f, 11.0f, 12.0f,
5003 13.0f, 14.0f, 15.0f,
5009 16.0f, 17.0f, 18.0f,
5015 LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(
5016 armnn::IWorkloadFactory& workloadFactory,
5017 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5019 return Concatenation2dDim0DiffInputDimsTestImpl<armnn::DataType::Float32>(
5020 workloadFactory, memoryManager, 0.0f, 0);
5023 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5024 LayerTestResult<T, 2> Concatenation2dDim1DiffInputDimsTestImpl(
5025 armnn::IWorkloadFactory& workloadFactory,
5026 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5030 armnn::TensorInfo input0TensorInfo({ 2, 3 }, ArmnnType, qScale, qOffset);
5031 auto input0 = MakeTensor<T, 2>(input0TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5036 10.0f, 11.0f, 12.0f,
5039 armnn::TensorInfo input1TensorInfo({ 2, 5 }, ArmnnType, qScale, qOffset);
5040 auto input1 = MakeTensor<T, 2>(input1TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5042 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
5045 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
5048 armnn::TensorInfo input2TensorInfo({ 2, 1 }, ArmnnType, qScale, qOffset);
5049 auto input2 = MakeTensor<T, 2>(input2TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5057 armnn::TensorInfo outputTensorInfo({ 2, 9 }, ArmnnType, qScale, qOffset);
5058 LayerTestResult<T, 2> result(outputTensorInfo);
5060 std::vector<T> output;
5061 output.resize(outputTensorInfo.GetNumElements());
5062 Concatenate<T>(workloadFactory, memoryManager,
5063 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
5064 { input0.data(), input1.data(), input2.data() },
5070 result.output = MakeTensor<T, 2>(outputTensorInfo, output);
5071 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5073 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f,
5076 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f,
5082 LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(
5083 armnn::IWorkloadFactory& workloadFactory,
5084 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5086 return Concatenation2dDim1DiffInputDimsTestImpl<armnn::DataType::Float32>(
5087 workloadFactory, memoryManager, 0.0f, 0);
5090 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5091 LayerTestResult<T, 3> Concatenation3dTestImpl(
5092 armnn::IWorkloadFactory& workloadFactory,
5093 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5094 const armnn::TensorInfo& outputTensorInfo,
5095 unsigned int dimension,
5100 armnn::TensorInfo inputTensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
5102 auto input0 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5103 // Batch 0, Channel 0
5106 // Batch 0, Channel 1
5109 // Batch 0, Channel 2
5112 // Batch 1, Channel 0
5115 // Batch 1, Channel 1
5118 // Batch 1, Channel 2
5122 auto input1 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5123 // Batch 0, Channel 0
5126 // Batch 0, Channel 1
5129 // Batch 0, Channel 2
5132 // Batch 1, Channel 0
5135 // Batch 1, Channel 1
5138 // Batch 1, Channel 2
5142 auto input2 = MakeTensor<T, 3>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5143 // Batch 0, Channel 0
5146 // Batch 0, Channel 1
5149 // Batch 0, Channel 2
5152 // Batch 1, Channel 0
5155 // Batch 1, Channel 1
5158 // Batch 1, Channel 2
5162 LayerTestResult<T, 3> result(outputTensorInfo);
5164 std::vector<T> output;
5165 output.resize(outputTensorInfo.GetNumElements());
5166 Concatenate<T>(workloadFactory, memoryManager,
5167 { inputTensorInfo, inputTensorInfo, inputTensorInfo },
5168 { input0.data(), input1.data(), input2.data() },
5174 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
5178 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5179 LayerTestResult<T, 3> Concatenation3dDim0TestImpl(
5180 armnn::IWorkloadFactory& workloadFactory,
5181 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5185 armnn::TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType, qScale, qOffset);
5187 LayerTestResult<T, 3> result = Concatenation3dTestImpl<ArmnnType>(
5188 workloadFactory, memoryManager, outputTensorInfo, 0, true, qScale, qOffset);
5190 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5191 // Batch 0, Channel 0
5194 // Batch 0, Channel 1
5197 // Batch 0, Channel 2
5200 // Batch 1, Channel 0
5203 // Batch 1, Channel 1
5206 // Batch 1, Channel 2
5209 // Batch 2, Channel 0
5212 // Batch 2, Channel 1
5215 // Batch 2, Channel 2
5218 // Batch 3, Channel 0
5221 // Batch 3, Channel 1
5224 // Batch 3, Channel 2
5227 // Batch 4, Channel 0
5230 // Batch 4, Channel 1
5233 // Batch 4, Channel 2
5236 // Batch 5, Channel 0
5239 // Batch 5, Channel 1
5242 // Batch 5, Channel 2
5249 LayerTestResult<float, 3> Concatenation3dDim0Test(
5250 armnn::IWorkloadFactory& workloadFactory,
5251 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5253 return Concatenation3dDim0TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
5256 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5257 LayerTestResult<T, 3> Concatenation3dDim1TestImpl(
5258 armnn::IWorkloadFactory& workloadFactory,
5259 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5263 armnn::TensorInfo outputTensorInfo({ 2, 9, 2 }, ArmnnType, qScale, qOffset);
5265 LayerTestResult<T, 3> result = Concatenation3dTestImpl<ArmnnType>(
5266 workloadFactory, memoryManager, outputTensorInfo, 1, true, qScale, qOffset);
5268 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5269 // Batch 0, Channel 0
5272 // Batch 0, Channel 1
5275 // Batch 0, Channel 2
5278 // Batch 0, Channel 3
5281 // Batch 0, Channel 4
5284 // Batch 0, Channel 5
5287 // Batch 0, Channel 6
5290 // Batch 0, Channel 7
5293 // Batch 0, Channel 8
5296 // Batch 1, Channel 0
5299 // Batch 1, Channel 1
5302 // Batch 1, Channel 2
5305 // Batch 1, Channel 3
5308 // Batch 1, Channel 4
5311 // Batch 1, Channel 5
5314 // Batch 1, Channel 6
5317 // Batch 1, Channel 7
5320 // Batch 1, Channel 8
5327 LayerTestResult<float, 3> Concatenation3dDim1Test(
5328 armnn::IWorkloadFactory& workloadFactory,
5329 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5331 return Concatenation3dDim1TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
5334 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5335 LayerTestResult<T, 3> Concatenation3dDim2TestImpl(
5336 armnn::IWorkloadFactory& workloadFactory,
5337 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5342 armnn::TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
5344 LayerTestResult<T, 3> result = Concatenation3dTestImpl<ArmnnType>(
5345 workloadFactory, memoryManager, outputTensorInfo, 2, useSubtensor, qScale, qOffset);
5347 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5348 // Batch 0, Channel 0
5349 1.0f, 2.0f, 7.0f, 8.0f, 13.0f, 14.0f,
5351 // Batch 0, Channel 1
5352 3.0f, 4.0f, 9.0f, 10.0f, 15.0f, 16.0f,
5354 // Batch 0, Channel 2
5355 5.0f, 6.0f, 11.0f, 12.0f, 17.0f, 18.0f,
5357 // Batch 1, Channel 0
5358 19.0f, 20.0f, 25.0f, 26.0f, 31.0f, 32.0f,
5360 // Batch 1, Channel 1
5361 21.0f, 22.0f, 27.0f, 28.0f, 33.0f, 34.0f,
5363 // Batch 1, Channel 2
5364 23.0f, 24.0f, 29.0f, 30.0f, 35.0f, 36.0f,
5370 LayerTestResult<float, 3> Concatenation3dDim2Test(
5371 armnn::IWorkloadFactory& workloadFactory,
5372 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5375 return Concatenation3dDim2TestImpl<armnn::DataType::Float32>(
5376 workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
5379 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5380 LayerTestResult<T, 3> Concatenation3dDim0DiffInputDimsTestImpl(
5381 armnn::IWorkloadFactory& workloadFactory,
5382 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5386 armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType);
5387 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5388 // Batch 0, Channel 0
5391 // Batch 0, Channel 1
5394 // Batch 0, Channel 2
5397 // Batch 1, Channel 0
5400 // Batch 1, Channel 1
5403 // Batch 1, Channel 2
5407 armnn::TensorInfo input1TensorInfo({ 1, 3, 2 }, ArmnnType);
5408 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5409 // Batch 0, Channel 0
5412 // Batch 0, Channel 1
5415 // Batch 0, Channel 2
5419 armnn::TensorInfo input2TensorInfo({ 3, 3, 2 }, ArmnnType);
5420 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5421 // Batch 0, Channel 0
5424 // Batch 0, Channel 1
5427 // Batch 0, Channel 2
5430 // Batch 1, Channel 0
5433 // Batch 1, Channel 1
5436 // Batch 1, Channel 2
5439 // Batch 2, Channel 0
5442 // Batch 2, Channel 1
5445 // Batch 2, Channel 2
5449 armnn::TensorInfo outputTensorInfo({ 6, 3, 2 }, ArmnnType);
5450 LayerTestResult<T, 3> result(outputTensorInfo);
5452 std::vector<T> output;
5453 output.resize(outputTensorInfo.GetNumElements());
5454 Concatenate<T>(workloadFactory, memoryManager,
5455 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
5456 { input0.data(), input1.data(), input2.data() },
5462 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
5463 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5464 // Batch 0, Channel 0
5467 // Batch 0, Channel 1
5470 // Batch 0, Channel 2
5473 // Batch 1, Channel 0
5476 // Batch 1, Channel 1
5479 // Batch 1, Channel 2
5482 // Batch 2, Channel 0
5485 // Batch 2, Channel 1
5488 // Batch 2, Channel 2
5491 // Batch 3, Channel 0
5494 // Batch 3, Channel 1
5497 // Batch 3, Channel 2
5500 // Batch 4, Channel 0
5503 // Batch 4, Channel 1
5506 // Batch 4, Channel 2
5509 // Batch 5, Channel 0
5512 // Batch 5, Channel 1
5515 // Batch 5, Channel 2
5522 LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(
5523 armnn::IWorkloadFactory& workloadFactory,
5524 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5526 return Concatenation3dDim0DiffInputDimsTestImpl<armnn::DataType::Float32>(
5527 workloadFactory, memoryManager, 0.0f, 0);
5530 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5531 LayerTestResult<T, 3> Concatenation3dDim1DiffInputDimsTestImpl(
5532 armnn::IWorkloadFactory& workloadFactory,
5533 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5537 armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
5538 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5539 // Batch 0, Channel 0
5542 // Batch 0, Channel 1
5545 // Batch 0, Channel 2
5548 // Batch 1, Channel 0
5551 // Batch 1, Channel 1
5554 // Batch 1, Channel 2
5558 armnn::TensorInfo input1TensorInfo({ 2, 4, 2 }, ArmnnType, qScale, qOffset);
5559 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5560 // Batch 0, Channel 0
5563 // Batch 0, Channel 1
5566 // Batch 0, Channel 2
5569 // Batch 0, Channel 3
5572 // Batch 1, Channel 0
5575 // Batch 1, Channel 1
5578 // Batch 1, Channel 2
5581 // Batch 1, Channel 3
5585 armnn::TensorInfo input2TensorInfo({ 2, 1, 2 }, ArmnnType, qScale, qOffset);
5586 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5587 // Batch 0, Channel 0
5590 // Batch 1, Channel 0
5594 armnn::TensorInfo outputTensorInfo({ 2, 8, 2 }, ArmnnType, qScale, qOffset);
5595 LayerTestResult<T, 3> result(outputTensorInfo);
5597 std::vector<T> output;
5598 output.resize(outputTensorInfo.GetNumElements());
5599 Concatenate<T>(workloadFactory, memoryManager,
5600 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
5601 { input0.data(), input1.data(), input2.data() },
5607 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
5608 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5609 // Batch 0, Channel 0
5612 // Batch 0, Channel 1
5615 // Batch 0, Channel 2
5618 // Batch 0, Channel 3
5621 // Batch 0, Channel 4
5624 // Batch 0, Channel 5
5627 // Batch 0, Channel 6
5630 // Batch 0, Channel 7
5633 // Batch 1, Channel 0
5636 // Batch 1, Channel 1
5639 // Batch 1, Channel 2
5642 // Batch 1, Channel 3
5645 // Batch 1, Channel 4
5648 // Batch 1, Channel 5
5651 // Batch 1, Channel 6
5654 // Batch 1, Channel 7
5661 LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(
5662 armnn::IWorkloadFactory& workloadFactory,
5663 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5665 return Concatenation3dDim1DiffInputDimsTestImpl<armnn::DataType::Float32>(
5666 workloadFactory, memoryManager, 0.0f, 0);
5669 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5670 LayerTestResult<T, 3> Concatenation3dDim2DiffInputDimsTestImpl(
5671 armnn::IWorkloadFactory& workloadFactory,
5672 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5677 armnn::TensorInfo input0TensorInfo({ 2, 3, 2 }, ArmnnType, qScale, qOffset);
5678 auto input0 = MakeTensor<T, 3>(input0TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5679 // Batch 0, Channel 0
5682 // Batch 0, Channel 1
5685 // Batch 0, Channel 2
5688 // Batch 1, Channel 0
5691 // Batch 1, Channel 1
5694 // Batch 1, Channel 2
5698 armnn::TensorInfo input1TensorInfo({ 2, 3, 1 }, ArmnnType, qScale, qOffset);
5699 auto input1 = MakeTensor<T, 3>(input1TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5700 // Batch 0, Channel 0
5703 // Batch 0, Channel 1
5706 // Batch 0, Channel 2
5709 // Batch 1, Channel 0
5712 // Batch 1, Channel 1
5715 // Batch 1, Channel 2
5719 armnn::TensorInfo input2TensorInfo({ 2, 3, 3 }, ArmnnType, qScale, qOffset);
5720 auto input2 = MakeTensor<T, 3>(input2TensorInfo, QuantizedVector<T>(qScale, qOffset, {
5721 // Batch 0, Channel 0
5722 13.0f, 14.0f, 50.0f,
5724 // Batch 0, Channel 1
5725 15.0f, 16.0f, 51.0f,
5727 // Batch 0, Channel 2
5728 17.0f, 18.0f, 52.0f,
5730 // Batch 1, Channel 0
5731 31.0f, 32.0f, 53.0f,
5733 // Batch 1, Channel 1
5734 33.0f, 34.0f, 54.0f,
5736 // Batch 1, Channel 2
5737 35.0f, 36.0f, 55.0f,
5740 armnn::TensorInfo outputTensorInfo({ 2, 3, 6 }, ArmnnType, qScale, qOffset);
5741 LayerTestResult<T, 3> result(outputTensorInfo);
5743 std::vector<T> output;
5744 output.resize(outputTensorInfo.GetNumElements());
5745 Concatenate<T>(workloadFactory, memoryManager,
5746 { input0TensorInfo, input1TensorInfo, input2TensorInfo },
5747 { input0.data(), input1.data(), input2.data() },
5753 result.output = MakeTensor<T, 3>(outputTensorInfo, output);
5754 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5755 // Batch 0, Channel 0
5756 1.0f, 2.0f, 7.0f, 13.0f, 14.0f, 50.0f,
5758 // Batch 0, Channel 1
5759 3.0f, 4.0f, 9.0f, 15.0f, 16.0f, 51.0f,
5761 // Batch 0, Channel 2
5762 5.0f, 6.0f, 11.0f, 17.0f, 18.0f, 52.0f,
5764 // Batch 1, Channel 0
5765 19.0f, 20.0f, 25.0f, 31.0f, 32.0f, 53.0f,
5767 // Batch 1, Channel 1
5768 21.0f, 22.0f, 27.0f, 33.0f, 34.0f, 54.0f,
5770 // Batch 1, Channel 2
5771 23.0f, 24.0f, 29.0f, 35.0f, 36.0f, 55.0f,
5777 LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(
5778 armnn::IWorkloadFactory& workloadFactory,
5779 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5782 return Concatenation3dDim2DiffInputDimsTestImpl<armnn::DataType::Float32>(
5783 workloadFactory, memoryManager, useSubtensor, 0.0f, 0);
5786 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5787 LayerTestResult<T, 4> Concatenation4dTestImpl(
5788 armnn::IWorkloadFactory& workloadFactory,
5789 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5790 const armnn::TensorInfo& outputTensorInfo,
5791 unsigned int dimension,
5796 armnn::TensorInfo inputTensorInfo({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
5798 auto input0 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5807 auto input1 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5816 auto input2 = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5825 LayerTestResult<T, 4> result(outputTensorInfo);
5827 std::vector<T> output;
5828 output.resize(outputTensorInfo.GetNumElements());
5830 Concatenate<T>(workloadFactory,
5832 {inputTensorInfo, inputTensorInfo, inputTensorInfo},
5833 {input0.data(), input1.data(), input2.data()},
5839 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
5843 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5844 LayerTestResult<T, 4> Concatenation4dDim0TestImpl(
5845 armnn::IWorkloadFactory& workloadFactory,
5846 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5850 armnn::TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
5852 LayerTestResult<T, 4> result = Concatenation4dTestImpl<ArmnnType>(
5853 workloadFactory, memoryManager, outputTensorInfo, 0, true, qScale, qOffset);
5855 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5880 LayerTestResult<float, 4> Concatenation4dDim0Test(
5881 armnn::IWorkloadFactory& workloadFactory,
5882 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5884 return Concatenation4dDim0TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
5887 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5888 LayerTestResult<T, 4> Concatenation4dDim1TestImpl(
5889 armnn::IWorkloadFactory& workloadFactory,
5890 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5894 armnn::TensorInfo outputTensorInfo({ 1, 9, 2, 2 }, ArmnnType, qScale, qOffset);
5896 LayerTestResult<T, 4> result = Concatenation4dTestImpl<ArmnnType>(
5897 workloadFactory, memoryManager, outputTensorInfo, 1, true, qScale, qOffset);
5899 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5925 LayerTestResult<float, 4> Concatenation4dDim1Test(
5926 armnn::IWorkloadFactory& workloadFactory,
5927 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5929 return Concatenation4dDim1TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
5932 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5933 LayerTestResult<T, 4> Concatenation4dDim2TestImpl(
5934 armnn::IWorkloadFactory& workloadFactory,
5935 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5939 armnn::TensorInfo outputTensorInfo({ 1, 3, 6, 2 }, ArmnnType, qScale, qOffset);
5941 LayerTestResult<T, 4> result = Concatenation4dTestImpl<ArmnnType>(
5942 workloadFactory, memoryManager, outputTensorInfo, 2, true, qScale, qOffset);
5944 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
5970 LayerTestResult<float, 4> Concatenation4dDim2Test(
5971 armnn::IWorkloadFactory& workloadFactory,
5972 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
5974 return Concatenation4dDim2TestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
5977 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
5978 LayerTestResult<T, 4> Concatenation4dDim3TestImpl(
5979 armnn::IWorkloadFactory& workloadFactory,
5980 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
5985 armnn::TensorInfo outputTensorInfo({ 1, 3, 2, 6 }, ArmnnType, qScale, qOffset);
5987 LayerTestResult<T, 4> result = Concatenation4dTestImpl<ArmnnType>(
5988 workloadFactory, memoryManager, outputTensorInfo, 3, useSubtensor, qScale, qOffset);
5990 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
6016 LayerTestResult<float, 4> Concatenation4dDim3Test(
6017 armnn::IWorkloadFactory& workloadFactory,
6018 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6021 return Concatenation4dDim3TestImpl<armnn::DataType::Float32>(
6022 workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
6025 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6026 LayerTestResult<T, 4> Concatenation4dDiffShapeDim0TestImpl(
6027 armnn::IWorkloadFactory& workloadFactory,
6028 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6032 unsigned int dimension = 0;
6033 armnn::TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6035 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(qScale, qOffset, {
6044 armnn::TensorInfo inputTensorInfo1({ 2, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6046 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset, {
6063 armnn::TensorInfo outputTensorInfo({ 3, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6065 LayerTestResult<T, 4> result(outputTensorInfo);
6067 std::vector<T> output;
6068 output.resize(outputTensorInfo.GetNumElements());
6069 Concatenate<T>(workloadFactory,
6071 {inputTensorInfo0, inputTensorInfo1},
6072 {input0.data(), input1.data()},
6078 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
6079 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
6105 LayerTestResult<float, 4> Concatenation4dDiffShapeDim0Test(
6106 armnn::IWorkloadFactory& workloadFactory,
6107 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6109 return Concatenation4dDiffShapeDim0TestImpl<armnn::DataType::Float32>(
6110 workloadFactory, memoryManager, 0.0f, 0);
6113 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6114 LayerTestResult<T, 4> Concatenation4dDiffShapeDim1TestImpl(
6115 armnn::IWorkloadFactory& workloadFactory,
6116 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6120 unsigned int dimension = 1;
6121 armnn::TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6123 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(qScale, qOffset, {
6132 armnn::TensorInfo inputTensorInfo1({ 1, 2, 2, 2 }, ArmnnType, qScale, qOffset);
6134 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset, {
6142 armnn::TensorInfo outputTensorInfo({ 1, 5, 2, 2 }, ArmnnType, qScale, qOffset);
6144 LayerTestResult<T, 4> result(outputTensorInfo);
6146 std::vector<T> output;
6147 output.resize(outputTensorInfo.GetNumElements());
6148 Concatenate<T>(workloadFactory,
6150 {inputTensorInfo0, inputTensorInfo1},
6151 {input0.data(), input1.data()},
6157 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
6158 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
6174 LayerTestResult<float, 4> Concatenation4dDiffShapeDim1Test(
6175 armnn::IWorkloadFactory& workloadFactory,
6176 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6178 return Concatenation4dDiffShapeDim1TestImpl<armnn::DataType::Float32>(
6179 workloadFactory, memoryManager, 0.0f, 0);
6182 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6183 LayerTestResult<T, 4> Concatenation4dDiffShapeDim2TestImpl(
6184 armnn::IWorkloadFactory& workloadFactory,
6185 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6189 unsigned int dimension = 2;
6190 armnn::TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6192 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(qScale, qOffset, {
6201 armnn::TensorInfo inputTensorInfo1({ 1, 3, 3, 2 }, ArmnnType, qScale, qOffset);
6203 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset, {
6215 armnn::TensorInfo outputTensorInfo({ 1, 3, 5, 2 }, ArmnnType, qScale, qOffset);
6217 LayerTestResult<T, 4> result(outputTensorInfo);
6219 std::vector<T> output;
6220 output.resize(outputTensorInfo.GetNumElements());
6221 Concatenate<T>(workloadFactory,
6223 {inputTensorInfo0, inputTensorInfo1},
6224 {input0.data(), input1.data()},
6230 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
6231 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
6254 LayerTestResult<float, 4> Concatenation4dDiffShapeDim2Test(
6255 armnn::IWorkloadFactory& workloadFactory,
6256 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6258 return Concatenation4dDiffShapeDim2TestImpl<armnn::DataType::Float32>(
6259 workloadFactory, memoryManager, 0.0f, 0);
6262 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6263 LayerTestResult<T, 4> Concatenation4dDiffShapeDim3TestImpl(
6264 armnn::IWorkloadFactory& workloadFactory,
6265 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6270 unsigned int dimension = 3;
6271 armnn::TensorInfo inputTensorInfo0({ 1, 3, 2, 2 }, ArmnnType, qScale, qOffset);
6273 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, QuantizedVector<T>(qScale, qOffset, {
6282 armnn::TensorInfo inputTensorInfo1({ 1, 3, 2, 3 }, ArmnnType, qScale, qOffset);
6284 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, QuantizedVector<T>(qScale, qOffset, {
6285 11.0f, 12.0f, 13.0f,
6286 14.0f, 15.0f, 16.0f,
6288 17.0f, 18.0f, 19.0f,
6289 20.0f, 21.0f, 22.0f,
6291 23.0f, 24.0f, 25.0f,
6295 armnn::TensorInfo outputTensorInfo({ 1, 3, 2, 5 }, ArmnnType, qScale, qOffset);
6297 LayerTestResult<T, 4> result(outputTensorInfo);
6299 std::vector<T> output;
6300 output.resize(outputTensorInfo.GetNumElements());
6301 Concatenate<T>(workloadFactory,
6303 {inputTensorInfo0, inputTensorInfo1},
6304 {input0.data(), input1.data()},
6310 result.output = MakeTensor<T, 4>(outputTensorInfo, output);
6311 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(qScale, qOffset, {
6312 1.0f, 2.0f, 11.0f, 12.0f, 13.0f,
6313 3.0f, 4.0f, 14.0f, 15.0f, 16.0f,
6314 5.0f, 6.0f, 17.0f, 18.0f, 19.0f,
6315 7.0f, 8.0f, 20.0f, 21.0f, 22.0f,
6316 9.0f, 10.0f, 23.0f, 24.0f, 25.0f,
6317 11.0f, 12.0f, 26.0f, 27.0f, 28.0f
6323 LayerTestResult<float, 4> Concatenation4dDiffShapeDim3Test(
6324 armnn::IWorkloadFactory& workloadFactory,
6325 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6328 return Concatenation4dDiffShapeDim3TestImpl<armnn::DataType::Float32>(
6329 workloadFactory, memoryManager, 0.0f, 0, useSubtensor);
6332 LayerTestResult<float, 2> FakeQuantizationTest(
6333 armnn::IWorkloadFactory& workloadFactory,
6334 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6336 constexpr unsigned int width = 2;
6337 constexpr unsigned int height = 3;
6339 const armnn::TensorInfo tensorInfo({height, width },
6340 armnn::DataType::Float32);
6341 auto input = MakeTensor<float, 2>(tensorInfo, std::vector<float>({
6347 LayerTestResult<float, 2> ret(tensorInfo);
6349 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(tensorInfo);
6351 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(tensorInfo);
6353 armnn::FakeQuantizationQueueDescriptor data;
6354 armnn::WorkloadInfo info;
6356 AddInputToWorkload(data, info, tensorInfo, inputHandle.get());
6357 AddOutputToWorkload(data, info, tensorInfo, outputHandle.get());
6361 data.m_Parameters.m_Min = min;
6362 data.m_Parameters.m_Max = max;
6364 armnn::PassthroughCpuTensorHandle refHandle(tensorInfo, &ret.outputExpected[0][0]);
6365 armnn::FakeQuantizationQueueDescriptor refData = data;
6366 armnn::WorkloadInfo refInfo = info;
6367 SetWorkloadOutput(refData, refInfo, 0, tensorInfo, &refHandle);
6369 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFakeQuantization(data, info);
6371 inputHandle->Allocate();
6372 outputHandle->Allocate();
6374 CopyDataToITensorHandle(inputHandle.get(), &input[0][0]);
6376 workload->PostAllocationConfigure();
6377 workload->Execute();
6379 CopyDataFromITensorHandle(&ret.output[0][0], outputHandle.get());
6381 ret.outputExpected = MakeTensor<float, 2>(tensorInfo, std::vector<float>({
6391 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6392 LayerTestResult<T, 4> L2NormalizationTestImpl(
6393 armnn::IWorkloadFactory& workloadFactory,
6394 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6395 const armnn::TensorShape& inputOutputTensorShape,
6398 const std::vector<float>& inputValues,
6401 const std::vector<float>& expectedOutputValues,
6402 const armnn::DataLayout layout,
6403 float epsilon = 1e-12f)
6405 const armnn::TensorInfo inputTensorInfo(inputOutputTensorShape, ArmnnType, scale, offset);
6406 const armnn::TensorInfo outputTensorInfo(inputOutputTensorShape, ArmnnType, outScale, outOffset);
6408 // at this point if we require it permute the input data
6409 const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
6410 std::vector<float> inputData = inputValues;
6411 if (layout == armnn::DataLayout::NHWC)
6413 std::vector<float> tmp(inputData.size());
6414 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
6418 auto inputTensor = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(
6419 inputTensorInfo.GetQuantizationScale(),
6420 inputTensorInfo.GetQuantizationOffset(),
6423 std::vector<float> expectedOutputData = expectedOutputValues;
6424 if (layout == armnn::DataLayout::NHWC)
6426 std::vector<float> tmp(expectedOutputData.size());
6427 armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, expectedOutputData.data(), tmp.data(),
6429 expectedOutputData = tmp;
6432 LayerTestResult<T, 4> result(outputTensorInfo);
6433 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, QuantizedVector<T>(
6434 outputTensorInfo.GetQuantizationScale(),
6435 outputTensorInfo.GetQuantizationOffset(),
6436 expectedOutputData));
6438 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
6439 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
6441 armnn::L2NormalizationQueueDescriptor descriptor;
6442 descriptor.m_Parameters.m_Eps = epsilon;
6443 descriptor.m_Parameters.m_DataLayout = layout;
6444 armnn::WorkloadInfo info;
6446 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
6447 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
6449 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateL2Normalization(descriptor, info);
6451 inputHandle->Allocate();
6452 outputHandle->Allocate();
6454 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0][0]);
6456 workload->PostAllocationConfigure();
6457 ExecuteWorkload(*workload, memoryManager);
6459 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
6464 float CalcInvL2Norm(std::initializer_list<float> elements)
6466 const float reduction = std::accumulate(elements.begin(), elements.end(), 0.0f,
6467 [](float acc, float element) { return acc + element * element; });
6468 return 1.0f / sqrtf(reduction);
6471 } // anonymous namespace
6473 template<armnn::DataType ArmnnType, typename T>
6474 LayerTestResult<T, 2> Pad2dTestCommon(
6475 armnn::IWorkloadFactory& workloadFactory,
6476 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6479 const float customPaddingValue)
6481 const armnn::TensorShape inputShape{ 3, 3 };
6482 const armnn::TensorShape outputShape{ 7, 7 };
6484 const armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType, qScale, qOffset);
6485 const armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType, qScale, qOffset);
6487 std::vector<T> inputValues(
6488 QuantizedVector<T>(qScale, qOffset,
6490 // Height (3) x Width (3)
6496 auto p = customPaddingValue;
6497 std::vector<T> expectedOutputValues;
6498 expectedOutputValues = (
6499 QuantizedVector<T>(qScale, qOffset,
6501 p, p, p, p, p, p, p,
6502 p, p, p, p, p, p, p,
6503 p, p, 4, 8, 6, p, p,
6504 p, p, 7, 4, 4, p, p,
6505 p, p, 3, 2, 4, p, p,
6506 p, p, p, p, p, p, p,
6510 auto inputTensor = MakeTensor<T, 2>(inputTensorInfo, std::vector<T>(inputValues));
6512 LayerTestResult<T, 2> result(outputTensorInfo);
6513 result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, std::vector<T>(expectedOutputValues));
6515 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
6516 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
6518 armnn::PadQueueDescriptor descriptor;
6520 std::vector<std::pair<unsigned int, unsigned int>> padList;
6521 padList.push_back(std::pair<unsigned int, unsigned int>(2,2));
6522 padList.push_back(std::pair<unsigned int, unsigned int>(2,2));
6524 descriptor.m_Parameters.m_PadList = padList;
6525 descriptor.m_Parameters.m_PadValue = customPaddingValue;
6526 armnn::WorkloadInfo info;
6528 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
6529 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
6531 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePad(descriptor, info);
6533 inputHandle->Allocate();
6534 outputHandle->Allocate();
6536 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
6538 workload->PostAllocationConfigure();
6539 workload->Execute();
6541 CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
6546 template<armnn::DataType ArmnnType, typename T>
6547 LayerTestResult<T, 3> Pad3dTestCommon(
6548 armnn::IWorkloadFactory& workloadFactory,
6549 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6553 const armnn::TensorShape inputShape{ 2, 2, 2 };
6554 const armnn::TensorShape outputShape{ 3, 5, 6 };
6556 const armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType, qScale, qOffset);
6557 const armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType, qScale, qOffset);
6559 std::vector<T> inputValues(
6560 QuantizedVector<T>(qScale,qOffset,
6562 // Channel 0, Height (2) x Width (2)
6566 // Channel 1, Height (2) x Width (2)
6571 std::vector<T> expectedOutputValues(
6572 QuantizedVector<T>(qScale,qOffset,
6595 auto inputTensor = MakeTensor<T, 3>(inputTensorInfo, std::vector<T>(inputValues));
6597 LayerTestResult<T, 3> result(outputTensorInfo);
6598 result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(expectedOutputValues));
6600 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
6601 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
6603 armnn::PadQueueDescriptor descriptor;
6605 std::vector<std::pair<unsigned int, unsigned int>> PadList;
6606 PadList.push_back(std::pair<unsigned int, unsigned int>(0,1));
6607 PadList.push_back(std::pair<unsigned int, unsigned int>(2,1));
6608 PadList.push_back(std::pair<unsigned int, unsigned int>(2,2));
6610 descriptor.m_Parameters.m_PadList = PadList;
6611 armnn::WorkloadInfo info;
6613 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
6614 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
6616 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePad(descriptor, info);
6618 inputHandle->Allocate();
6619 outputHandle->Allocate();
6621 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0]);
6623 workload->PostAllocationConfigure();
6624 workload->Execute();
6626 CopyDataFromITensorHandle(&result.output[0][0][0], outputHandle.get());
6631 template<armnn::DataType ArmnnType, typename T>
6632 LayerTestResult<T, 4> Pad4dTestCommon(
6633 armnn::IWorkloadFactory& workloadFactory,
6634 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6638 const armnn::TensorShape inputShape{ 2, 2, 3, 2 };
6639 const armnn::TensorShape outputShape{ 4, 5, 7, 4 };
6641 const armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType, qScale, qOffset);
6642 const armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType, qScale, qOffset);
6644 std::vector<T> inputValues(
6645 QuantizedVector<T>(qScale,qOffset,
6647 // Batch 0, Channel 0, Height (3) x Width (2)
6652 // Batch 0, Channel 1, Height (3) x Width (2)
6657 // Batch 1, Channel 0, Height (3) x Width (2)
6662 // Batch 1, Channel 1, Height (3) x Width (2)
6668 std::vector<T> expectedOutputValues(
6669 QuantizedVector<T>(qScale,qOffset,
6832 auto inputTensor = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(inputValues));
6834 LayerTestResult<T, 4> result(outputTensorInfo);
6835 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, std::vector<T>(expectedOutputValues));
6837 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
6838 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
6840 armnn::PadQueueDescriptor descriptor;
6842 std::vector<std::pair<unsigned int, unsigned int>> PadList;
6843 PadList.push_back(std::pair<unsigned int, unsigned int>(1,1));
6844 PadList.push_back(std::pair<unsigned int, unsigned int>(2,1));
6845 PadList.push_back(std::pair<unsigned int, unsigned int>(3,1));
6846 PadList.push_back(std::pair<unsigned int, unsigned int>(1,1));
6848 descriptor.m_Parameters.m_PadList = PadList;
6849 armnn::WorkloadInfo info;
6851 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
6852 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
6854 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePad(descriptor, info);
6856 inputHandle->Allocate();
6857 outputHandle->Allocate();
6859 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0][0]);
6861 workload->PostAllocationConfigure();
6862 workload->Execute();
6864 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
6869 LayerTestResult<uint8_t, 2> PadUint82dTest(
6870 armnn::IWorkloadFactory& workloadFactory,
6871 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6873 return Pad2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
6876 LayerTestResult<uint8_t, 2> PadUint82dCustomPaddingTest(
6877 armnn::IWorkloadFactory& workloadFactory,
6878 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6880 return Pad2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0, 1.0f);
6883 LayerTestResult<uint8_t, 3> PadUint83dTest(
6884 armnn::IWorkloadFactory& workloadFactory,
6885 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6887 return Pad3dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
6890 LayerTestResult<uint8_t, 4> PadUint84dTest(
6891 armnn::IWorkloadFactory& workloadFactory,
6892 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6894 return Pad4dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
6898 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 2>
6899 Pad2dTestCommon<armnn::DataType::QuantisedSymm16>(
6900 armnn::IWorkloadFactory& workloadFactory,
6901 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6904 const float customPaddingValue);
6906 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 3>
6907 Pad3dTestCommon<armnn::DataType::QuantisedSymm16>(
6908 armnn::IWorkloadFactory& workloadFactory,
6909 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6913 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
6914 Pad4dTestCommon<armnn::DataType::QuantisedSymm16>(
6915 armnn::IWorkloadFactory& workloadFactory,
6916 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6920 LayerTestResult<float, 2> PadFloat322dTest(
6921 armnn::IWorkloadFactory& workloadFactory,
6922 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6924 return Pad2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
6927 LayerTestResult<float, 2> PadFloat322dCustomPaddingTest(
6928 armnn::IWorkloadFactory& workloadFactory,
6929 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6931 return Pad2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0, 1.0f);
6934 LayerTestResult<float, 3> PadFloat323dTest(
6935 armnn::IWorkloadFactory& workloadFactory,
6936 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6938 return Pad3dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
6941 LayerTestResult<float, 4> PadFloat324dTest(
6942 armnn::IWorkloadFactory& workloadFactory,
6943 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
6945 return Pad4dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
6948 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
6949 LayerTestResult<T, 4> L2NormalizationEpsilonTestCommon(
6950 armnn::IWorkloadFactory& workloadFactory,
6951 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
6956 const armnn::DataLayout layout,
6963 unsigned int numberOfBatches = 1;
6964 unsigned int numberOfChannels = 3;
6965 unsigned int height = 1;
6966 unsigned int width = 1;
6968 const armnn::TensorShape inputOutputShape = armnnUtils::GetTensorShape(
6969 numberOfBatches, numberOfChannels, height, width, layout);
6971 // 0.0000001^2 + 0.00000002^2 + 0.00000003^2 < 1e-12
6972 std::vector<float> inputValues
6974 // Batch 0, Channel 0, Height (1) x Width (1)
6977 // Batch 0, Channel 1, Height (1) x Width (1)
6980 // Batch 0, Channel 2, Height (1) x Width (1)
6984 const float approxInvL2Norm = 1.f / sqrtf(epsilon);
6985 std::vector<float> expectedOutputValues
6987 // Batch 0, Channel 0, Height (1) x Width (1)
6988 0.00000001f * approxInvL2Norm,
6989 0.00000002f * approxInvL2Norm,
6990 0.00000003f * approxInvL2Norm,
6993 return L2NormalizationTestImpl<ArmnnType>(workloadFactory, memoryManager, inputOutputShape, scale, offset,
6994 inputValues, outScale, outOffset, expectedOutputValues, layout,
6999 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
7000 LayerTestResult<T, 4> L2Normalization1dTestCommon(
7001 armnn::IWorkloadFactory& workloadFactory,
7002 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7007 const armnn::DataLayout layout)
7013 unsigned int numberOfBatches = 1;
7014 unsigned int numberOfChannels = 10;
7015 unsigned int height = 1;
7016 unsigned int width = 1;
7019 const armnn::TensorShape inputOutputShape = armnnUtils::GetTensorShape(
7020 numberOfBatches, numberOfChannels, height, width, layout);
7021 std::vector<float> inputValues
7023 // Batch 0, Channel 0, Height (1) x Width (1)
7026 // Batch 0, Channel 1, Height (1) x Width (1)
7029 // Batch 0, Channel 2, Height (1) x Width (1)
7032 // Batch 0, Channel 3, Height (1) x Width (1)
7035 // Batch 0, Channel 4, Height (1) x Width (1)
7038 // Batch 0, Channel 5, Height (1) x Width (1)
7041 // Batch 0, Channel 6, Height (1) x Width (1)
7044 // Batch 0, Channel 7, Height (1) x Width (1)
7047 // Batch 0, Channel 8, Height (1) x Width (1)
7050 // Batch 0, Channel 9, Height (1) x Width (1)
7053 const float approxInvL2Norm = 0.050964719f;
7054 std::vector<float> expectedOutputValues
7056 // Batch 0, Channel 0, Height (1) x Width (1)
7057 1.0f * approxInvL2Norm,
7058 2.0f * approxInvL2Norm,
7059 3.0f * approxInvL2Norm,
7060 4.0f * approxInvL2Norm,
7061 5.0f * approxInvL2Norm,
7062 6.0f * approxInvL2Norm,
7063 7.0f * approxInvL2Norm,
7064 8.0f * approxInvL2Norm,
7065 9.0f * approxInvL2Norm,
7066 10.0f * approxInvL2Norm
7070 return L2NormalizationTestImpl<ArmnnType>(workloadFactory, memoryManager, inputOutputShape, scale, offset,
7071 inputValues, outScale, outOffset, expectedOutputValues, layout);
7074 LayerTestResult<float, 4> L2NormalizationDefaultEpsilonTest(
7075 armnn::IWorkloadFactory& workloadFactory,
7076 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7077 const armnn::DataLayout layout)
7079 // Dummy descriptor to get the default value of epsilon.
7080 armnn::L2NormalizationDescriptor descriptor;
7082 return L2NormalizationEpsilonTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,
7083 layout, descriptor.m_Eps);
7086 LayerTestResult<float, 4> L2NormalizationNonDefaultEpsilonTest(
7087 armnn::IWorkloadFactory& workloadFactory,
7088 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7089 const armnn::DataLayout layout)
7091 return L2NormalizationEpsilonTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,
7095 LayerTestResult<float, 4> L2Normalization1dTest(
7096 armnn::IWorkloadFactory& workloadFactory,
7097 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7098 const armnn::DataLayout layout)
7100 return L2Normalization1dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,layout);
7103 LayerTestResult<int16_t, 4> L2Normalization1dInt16Test(
7104 armnn::IWorkloadFactory& workloadFactory,
7105 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7106 const armnn::DataLayout layout)
7108 return L2Normalization1dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.f, 0, 1.f, 0,
7112 LayerTestResult<uint8_t, 4> L2Normalization1dUint8Test(
7113 armnn::IWorkloadFactory& workloadFactory,
7114 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7115 const armnn::DataLayout layout)
7117 return L2Normalization1dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.f, 0,
7118 1.f/128, 128, layout);
7121 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
7122 LayerTestResult<T, 4> L2Normalization2dTestCommon(
7123 armnn::IWorkloadFactory& workloadFactory,
7124 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7129 const armnn::DataLayout layout)
7135 unsigned int numberOfBatches = 1;
7136 unsigned int numberOfChannels = 2;
7137 unsigned int height = 1;
7138 unsigned int width = 5;
7140 const armnn::TensorShape inputOutputShape = armnnUtils::GetTensorShape(
7141 numberOfBatches, numberOfChannels, height, width, layout);
7142 std::vector<float> inputValues
7144 // Batch 0, Channel 0, Height (1) x Width (5)
7145 1.0f, 3.0f, 5.0f, 7.0f, 9.0f,
7147 // Batch 0, Channel 1, Height (1) x Width (5)
7148 2.0f, 4.0f, 6.0f, 8.0f, 10.0f
7150 std::vector<float> expectedOutputValues
7152 // Batch 0, Channel 0, Height (1) x Width (5)
7153 1.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
7154 3.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
7155 5.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
7156 7.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
7157 9.0f * CalcInvL2Norm({ 9.0f, 10.0f }),
7159 // Batch 0, Channel 1, Height (1) x Width (5)
7160 2.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
7161 4.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
7162 6.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
7163 8.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
7164 10.0f * CalcInvL2Norm({ 9.0f, 10.0f })
7167 return L2NormalizationTestImpl<ArmnnType>(workloadFactory, memoryManager, inputOutputShape, scale, offset,
7168 inputValues, outScale, outOffset, expectedOutputValues, layout);
7171 LayerTestResult<float, 4> L2Normalization2dTest(
7172 armnn::IWorkloadFactory& workloadFactory,
7173 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7174 const armnn::DataLayout layout)
7176 return L2Normalization2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,
7180 LayerTestResult<int16_t, 4> L2Normalization2dInt16Test(
7181 armnn::IWorkloadFactory& workloadFactory,
7182 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7183 const armnn::DataLayout layout)
7185 return L2Normalization1dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.f, 0, 1.f, 0,
7189 LayerTestResult<uint8_t, 4> L2Normalization2dUint8Test(
7190 armnn::IWorkloadFactory& workloadFactory,
7191 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7192 const armnn::DataLayout layout)
7194 return L2Normalization1dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.f, 0,
7195 1.f/128, 128, layout);
7198 LayerTestResult<float, 2> L2Normalization2dShapeTest(
7199 armnn::IWorkloadFactory& workloadFactory,
7200 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7202 const armnn::DataLayout layout = armnn::DataLayout::NHWC;
7203 const armnn::TensorShape inputOutputTensorShape = armnn::TensorShape({ 5, 2 });
7205 std::vector<float> inputData
7207 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f
7209 std::vector<float> expectedOutputData
7211 1.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
7212 2.0f * CalcInvL2Norm({ 1.0f, 2.0f }),
7213 3.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
7214 4.0f * CalcInvL2Norm({ 3.0f, 4.0f }),
7215 5.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
7216 6.0f * CalcInvL2Norm({ 5.0f, 6.0f }),
7217 7.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
7218 8.0f * CalcInvL2Norm({ 7.0f, 8.0f }),
7219 9.0f * CalcInvL2Norm({ 9.0f, 10.0f }),
7220 10.0f * CalcInvL2Norm({ 9.0f, 10.0f })
7223 const armnn::TensorInfo inputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32, 0.f, 0);
7224 const armnn::TensorInfo outputTensorInfo(inputOutputTensorShape, armnn::DataType::Float32, 0.f, 0);
7226 auto inputTensor = MakeTensor<float, 2>(inputTensorInfo, QuantizedVector<float>(
7227 inputTensorInfo.GetQuantizationScale(),
7228 inputTensorInfo.GetQuantizationOffset(),
7231 LayerTestResult<float, 2> result(outputTensorInfo);
7232 result.outputExpected = MakeTensor<float, 2>(outputTensorInfo, QuantizedVector<float>(
7233 outputTensorInfo.GetQuantizationScale(),
7234 outputTensorInfo.GetQuantizationOffset(),
7235 expectedOutputData));
7237 std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
7238 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
7240 armnn::L2NormalizationQueueDescriptor descriptor;
7241 descriptor.m_Parameters.m_Eps = 1e-12f;
7242 descriptor.m_Parameters.m_DataLayout = layout;
7243 armnn::WorkloadInfo info;
7245 AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
7246 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
7248 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateL2Normalization(descriptor, info);
7250 inputHandle->Allocate();
7251 outputHandle->Allocate();
7253 CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
7255 workload->PostAllocationConfigure();
7256 ExecuteWorkload(*workload, memoryManager);
7258 CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
7263 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
7264 LayerTestResult<T, 4> L2Normalization3dTestCommon(
7265 armnn::IWorkloadFactory& workloadFactory,
7266 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7271 const armnn::DataLayout layout)
7277 unsigned int numberOfBatches = 1;
7278 unsigned int numberOfChannels = 2;
7279 unsigned int height = 4;
7280 unsigned int width = 3;
7282 const armnn::TensorShape inputOutputShape = armnnUtils::GetTensorShape(
7283 numberOfBatches, numberOfChannels, height, width, layout);
7284 std::vector<float> inputValues
7286 // Batch 0, Channel 0, Height (4) x Width (3)
7287 119.0f, 21.0f, 150.0f,
7288 149.0f, 32.0f, 179.0f,
7289 15.0f, 227.0f, 141.0f,
7290 147.0f, 199.0f, 220.0f,
7292 // Batch 0, Channel 1, Height (4) x Width (3)
7293 110.0f, 140.0f, 73.0f,
7294 211.0f, 212.0f, 89.0f,
7295 24.0f, 138.0f, 188.0f,
7296 162.0f, 12.0f, 161.0f
7298 std::vector<float> expectedOutputValues
7300 // Batch 0, Channel 0, Height (4) x Width (3)
7301 119.0f * CalcInvL2Norm({ 119.0f, 110.0f }),
7302 21.0f * CalcInvL2Norm({ 21.0f, 140.0f }),
7303 150.0f * CalcInvL2Norm({ 150.0f, 73.0f }),
7304 149.0f * CalcInvL2Norm({ 149.0f, 211.0f }),
7305 32.0f * CalcInvL2Norm({ 32.0f, 212.0f }),
7306 179.0f * CalcInvL2Norm({ 179.0f, 89.0f }),
7307 15.0f * CalcInvL2Norm({ 15.0f, 24.0f }),
7308 227.0f * CalcInvL2Norm({ 227.0f, 138.0f }),
7309 141.0f * CalcInvL2Norm({ 141.0f, 188.0f }),
7310 147.0f * CalcInvL2Norm({ 147.0f, 162.0f }),
7311 199.0f * CalcInvL2Norm({ 199.0f, 12.0f }),
7312 220.0f * CalcInvL2Norm({ 220.0f, 161.0f }),
7314 // Batch 0, Channel 1, Height (4) x Width (3)
7315 110.0f * CalcInvL2Norm({ 119.0f, 110.0f }),
7316 140.0f * CalcInvL2Norm({ 21.0f, 140.0f }),
7317 73.0f * CalcInvL2Norm({ 150.0f, 73.0f }),
7318 211.0f * CalcInvL2Norm({ 149.0f, 211.0f }),
7319 212.0f * CalcInvL2Norm({ 32.0f, 212.0f }),
7320 89.0f * CalcInvL2Norm({ 179.0f, 89.0f }),
7321 24.0f * CalcInvL2Norm({ 15.0f, 24.0f }),
7322 138.0f * CalcInvL2Norm({ 227.0f, 138.0f }),
7323 188.0f * CalcInvL2Norm({ 141.0f, 188.0f }),
7324 162.0f * CalcInvL2Norm({ 147.0f, 162.0f }),
7325 12.0f * CalcInvL2Norm({ 199.0f, 12.0f }),
7326 161.0f * CalcInvL2Norm({ 220.0f, 161.0f })
7329 return L2NormalizationTestImpl<ArmnnType>(workloadFactory, memoryManager, inputOutputShape, scale, offset,
7330 inputValues, outScale, outOffset, expectedOutputValues, layout);
7333 LayerTestResult<float, 4> L2Normalization3dTest(
7334 armnn::IWorkloadFactory& workloadFactory,
7335 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7336 const armnn::DataLayout layout)
7338 return L2Normalization3dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,
7342 LayerTestResult<int16_t, 4> L2Normalization3dInt16Test(
7343 armnn::IWorkloadFactory& workloadFactory,
7344 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7345 const armnn::DataLayout layout)
7347 return L2Normalization1dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.f, 0, 1.f, 0,
7351 LayerTestResult<uint8_t, 4> L2Normalization3dUint8Test(
7352 armnn::IWorkloadFactory& workloadFactory,
7353 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7354 const armnn::DataLayout layout)
7356 return L2Normalization1dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.f, 0,
7357 1.f/128, 128, layout);
7360 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
7361 LayerTestResult<T, 4> L2Normalization4dTestCommon(
7362 armnn::IWorkloadFactory& workloadFactory,
7363 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7368 const armnn::DataLayout layout)
7374 unsigned int numberOfBatches = 2;
7375 unsigned int numberOfChannels = 3;
7376 unsigned int height = 4;
7377 unsigned int width = 3;
7379 const armnn::TensorShape inputOutputShape = armnnUtils::GetTensorShape(
7380 numberOfBatches, numberOfChannels, height, width, layout);
7381 std::vector<float> inputValues
7383 // Batch 0, Channel 0, Height (4) x Width (3)
7384 235.0f, 46.0f, 178.0f,
7385 100.0f, 123.0f, 19.0f,
7386 172.0f, 74.0f, 250.0f,
7387 6.0f, 195.0f, 80.0f,
7389 // Batch 0, Channel 1, Height (4) x Width (3)
7390 113.0f, 95.0f, 202.0f,
7391 77.0f, 114.0f, 71.0f,
7392 122.0f, 246.0f, 166.0f,
7393 82.0f, 28.0f, 37.0f,
7395 // Batch 0, Channel 2, Height (4) x Width (3)
7396 56.0f, 170.0f, 162.0f,
7397 194.0f, 89.0f, 254.0f,
7398 12.0f, 209.0f, 200.0f,
7401 // Batch 1, Channel 0, Height (4) x Width (3)
7402 67.0f, 90.0f, 49.0f,
7403 7.0f, 163.0f, 18.0f,
7404 25.0f, 117.0f, 103.0f,
7405 247.0f, 59.0f, 189.0f,
7407 // Batch 1, Channel 1, Height (4) x Width (3)
7408 239.0f, 104.0f, 199.0f,
7409 17.0f, 124.0f, 153.0f,
7410 222.0f, 217.0f, 75.0f,
7411 32.0f, 126.0f, 21.0f,
7413 // Batch 1, Channel 2, Height (4) x Width (3)
7414 97.0f, 145.0f, 215.0f,
7415 115.0f, 116.0f, 238.0f,
7416 226.0f, 16.0f, 132.0f,
7417 92.0f, 125.0f, 88.0f
7419 std::vector<float> expectedOutputValues
7421 // Batch 0, Channel 0, Height (4) x Width (3)
7422 235.0f * CalcInvL2Norm({ 235.0f, 113.0f, 56.0f }),
7423 46.0f * CalcInvL2Norm({ 46.0f, 95.0f, 170.0f }),
7424 178.0f * CalcInvL2Norm({ 178.0f, 202.0F, 162.0f }),
7425 100.0f * CalcInvL2Norm({ 100.0f, 77.0f, 194.0f }),
7426 123.0f * CalcInvL2Norm({ 123.0f, 114.0f, 89.0f }),
7427 19.0f * CalcInvL2Norm({ 19.0f, 71.0f, 254.0f }),
7428 172.0f * CalcInvL2Norm({ 172.0f, 122.0f, 12.0f }),
7429 74.0f * CalcInvL2Norm({ 74.0f, 246.0f, 209.0f }),
7430 250.0f * CalcInvL2Norm({ 250.0f, 166.0f, 200.0f }),
7431 6.0f * CalcInvL2Norm({ 6.0f, 82.0f, 1.0f }),
7432 195.0f * CalcInvL2Norm({ 195.0f, 28.0f, 64.0f }),
7433 80.0f * CalcInvL2Norm({ 80.0f, 37.0f, 54.0f }),
7435 // Batch 0, Channel 1, Height (4) x Width (3)
7436 113.0f * CalcInvL2Norm({ 235.0f, 113.0f, 56.0f }),
7437 95.0f * CalcInvL2Norm({ 46.0f, 95.0f, 170.0f }),
7438 202.0f * CalcInvL2Norm({ 178.0f, 202.0F, 162.0f }),
7439 77.0f * CalcInvL2Norm({ 100.0f, 77.0f, 194.0f }),
7440 114.0f * CalcInvL2Norm({ 123.0f, 114.0f, 89.0f }),
7441 71.0f * CalcInvL2Norm({ 19.0f, 71.0f, 254.0f }),
7442 122.0f * CalcInvL2Norm({ 172.0f, 122.0f, 12.0f }),
7443 246.0f * CalcInvL2Norm({ 74.0f, 246.0f, 209.0f }),
7444 166.0f * CalcInvL2Norm({ 250.0f, 166.0f, 200.0f }),
7445 82.0f * CalcInvL2Norm({ 6.0f, 82.0f, 1.0f }),
7446 28.0f * CalcInvL2Norm({ 195.0f, 28.0f, 64.0f }),
7447 37.0f * CalcInvL2Norm({ 80.0f, 37.0f, 54.0f }),
7449 // Batch 0, Channel 2, Height (4) x Width (3)
7450 56.0f * CalcInvL2Norm({ 235.0f, 113.0f, 56.0f }),
7451 170.0f * CalcInvL2Norm({ 46.0f, 95.0f, 170.0f }),
7452 162.0f * CalcInvL2Norm({ 178.0f, 202.0F, 162.0f }),
7453 194.0f * CalcInvL2Norm({ 100.0f, 77.0f, 194.0f }),
7454 89.0f * CalcInvL2Norm({ 123.0f, 114.0f, 89.0f }),
7455 254.0f * CalcInvL2Norm({ 19.0f, 71.0f, 254.0f }),
7456 12.0f * CalcInvL2Norm({ 172.0f, 122.0f, 12.0f }),
7457 209.0f * CalcInvL2Norm({ 74.0f, 246.0f, 209.0f }),
7458 200.0f * CalcInvL2Norm({ 250.0f, 166.0f, 200.0f }),
7459 1.0f * CalcInvL2Norm({ 6.0f, 82.0f, 1.0f }),
7460 64.0f * CalcInvL2Norm({ 195.0f, 28.0f, 64.0f }),
7461 54.0f * CalcInvL2Norm({ 80.0f, 37.0f, 54.0f }),
7463 // Batch 1, Channel 0, Height (4) x Width (3)
7464 67.0f * CalcInvL2Norm({ 67.0f, 239.0f, 97.0f }),
7465 90.0f * CalcInvL2Norm({ 90.0f, 104.0f, 145.0f }),
7466 49.0f * CalcInvL2Norm({ 49.0f, 199.0f, 215.0f }),
7467 7.0f * CalcInvL2Norm({ 7.0f, 17.0f, 115.0f }),
7468 163.0f * CalcInvL2Norm({ 163.0f, 124.0f, 116.0f }),
7469 18.0f * CalcInvL2Norm({ 18.0f, 153.0f, 238.0f }),
7470 25.0f * CalcInvL2Norm({ 25.0f, 222.0f, 226.0f }),
7471 117.0f * CalcInvL2Norm({ 117.0f, 217.0f, 16.0f }),
7472 103.0f * CalcInvL2Norm({ 103.0f, 75.0f, 132.0f }),
7473 247.0f * CalcInvL2Norm({ 247.0f, 32.0f, 92.0f }),
7474 59.0f * CalcInvL2Norm({ 59.0f, 126.0f, 125.0f }),
7475 189.0f * CalcInvL2Norm({ 189.0f, 21.0f, 88.0f }),
7477 // Batch 1, Channel 1, Height (4) x Width (3)
7478 239.0f * CalcInvL2Norm({ 67.0f, 239.0f, 97.0f }),
7479 104.0f * CalcInvL2Norm({ 90.0f, 104.0f, 145.0f }),
7480 199.0f * CalcInvL2Norm({ 49.0f, 199.0f, 215.0f }),
7481 17.0f * CalcInvL2Norm({ 7.0f, 17.0f, 115.0f }),
7482 124.0f * CalcInvL2Norm({ 163.0f, 124.0f, 116.0f }),
7483 153.0f * CalcInvL2Norm({ 18.0f, 153.0f, 238.0f }),
7484 222.0f * CalcInvL2Norm({ 25.0f, 222.0f, 226.0f }),
7485 217.0f * CalcInvL2Norm({ 117.0f, 217.0f, 16.0f }),
7486 75.0f * CalcInvL2Norm({ 103.0f, 75.0f, 132.0f }),
7487 32.0f * CalcInvL2Norm({ 247.0f, 32.0f, 92.0f }),
7488 126.0f * CalcInvL2Norm({ 59.0f, 126.0f, 125.0f }),
7489 21.0f * CalcInvL2Norm({ 189.0f, 21.0f, 88.0f }),
7491 // Batch 1, Channel 2, Height (4) x Width (3)
7492 97.0f * CalcInvL2Norm({ 67.0f, 239.0f, 97.0f }),
7493 145.0f * CalcInvL2Norm({ 90.0f, 104.0f, 145.0f }),
7494 215.0f * CalcInvL2Norm({ 49.0f, 199.0f, 215.0f }),
7495 115.0f * CalcInvL2Norm({ 7.0f, 17.0f, 115.0f }),
7496 116.0f * CalcInvL2Norm({ 163.0f, 124.0f, 116.0f }),
7497 238.0f * CalcInvL2Norm({ 18.0f, 153.0f, 238.0f }),
7498 226.0f * CalcInvL2Norm({ 25.0f, 222.0f, 226.0f }),
7499 16.0f * CalcInvL2Norm({ 117.0f, 217.0f, 16.0f }),
7500 132.0f * CalcInvL2Norm({ 103.0f, 75.0f, 132.0f }),
7501 92.0f * CalcInvL2Norm({ 247.0f, 32.0f, 92.0f }),
7502 125.0f * CalcInvL2Norm({ 59.0f, 126.0f, 125.0f }),
7503 88.0f * CalcInvL2Norm({ 189.0f, 21.0f, 88.0f })
7506 return L2NormalizationTestImpl<ArmnnType>(workloadFactory, memoryManager, inputOutputShape, scale, offset,
7507 inputValues, outScale, outOffset, expectedOutputValues, layout);
7510 LayerTestResult<float, 4> L2Normalization4dTest(
7511 armnn::IWorkloadFactory& workloadFactory,
7512 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7513 const armnn::DataLayout layout)
7515 return L2Normalization4dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.f, 0, 0.f, 0,
7519 LayerTestResult<int16_t, 4> L2Normalization4dInt16Test(
7520 armnn::IWorkloadFactory& workloadFactory,
7521 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7522 const armnn::DataLayout layout)
7524 return L2Normalization1dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.f, 0, 1.f, 0,
7528 LayerTestResult<uint8_t, 4> L2Normalization4dUint8Test(
7529 armnn::IWorkloadFactory& workloadFactory,
7530 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7531 const armnn::DataLayout layout)
7533 return L2Normalization1dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.f, 0,
7534 1.f/128, 128, layout);
7537 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
7538 LayerTestResult<T, 4> ConstantTestImpl(
7539 armnn::IWorkloadFactory& workloadFactory,
7540 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
7544 constexpr unsigned int inputWidth = 3;
7545 constexpr unsigned int inputHeight = 4;
7546 constexpr unsigned int inputChannels = 3;
7547 constexpr unsigned int inputBatchSize = 2;
7549 constexpr unsigned int outputWidth = inputWidth;
7550 constexpr unsigned int outputHeight = inputHeight;
7551 constexpr unsigned int outputChannels = inputChannels;
7552 constexpr unsigned int outputBatchSize = inputBatchSize;
7554 armnn::TensorInfo inputTensorInfo({ inputBatchSize, inputChannels, inputHeight, inputWidth },
7555 ArmnnType, qScale, qOffset);
7557 armnn::TensorInfo outputTensorInfo({ outputBatchSize, outputChannels, outputHeight, outputWidth },
7558 ArmnnType, qScale, qOffset);
7560 // Set quantization parameters if the requested type is a quantized type.
7561 if(armnn::IsQuantizedType<T>())
7563 inputTensorInfo.SetQuantizationScale(qScale);
7564 inputTensorInfo.SetQuantizationOffset(qOffset);
7565 outputTensorInfo.SetQuantizationScale(qScale);
7566 outputTensorInfo.SetQuantizationOffset(qOffset);
7569 auto input = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(
7570 QuantizedVector<T>(qScale, qOffset, {
7571 // Batch 0, Channel 0
7572 235.0f, 46.0f, 178.0f,
7573 100.0f, 123.0f, 19.0f,
7574 172.0f, 74.0f, 250.0f,
7575 6.0f, 195.0f, 80.0f,
7577 // Batch 0, Channel 1
7578 113.0f, 95.0f, 202.0f,
7579 77.0f, 114.0f, 71.0f,
7580 122.0f, 246.0f, 166.0f,
7581 82.0f, 28.0f, 37.0f,
7583 // Batch 0, Channel 2
7584 56.0f, 170.0f, 162.0f,
7585 194.0f, 89.0f, 254.0f,
7586 12.0f, 209.0f, 200.0f,
7589 // Batch 1, Channel 0
7590 67.0f, 90.0f, 49.0f,
7591 7.0f, 163.0f, 18.0f,
7592 25.0f, 117.0f, 103.0f,
7593 247.0f, 59.0f, 189.0f,
7595 // Batch 1, Channel 1
7596 239.0f, 104.0f, 199.0f,
7597 17.0f, 124.0f, 153.0f,
7598 222.0f, 217.0f, 75.0f,
7599 32.0f, 126.0f, 21.0f,
7601 // Batch 1, Channel 2
7602 97.0f, 145.0f, 215.0f,
7603 115.0f, 116.0f, 238.0f,
7604 226.0f, 16.0f, 132.0f,
7605 92.0f, 125.0f, 88.0f,
7608 LayerTestResult<T, 4> result(outputTensorInfo);
7609 result.outputExpected = input;
7611 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
7613 armnn::ScopedCpuTensorHandle constantTensor(inputTensorInfo);
7614 AllocateAndCopyDataToITensorHandle(&constantTensor, &input[0][0][0][0]);
7616 armnn::ConstantQueueDescriptor descriptor;
7617 descriptor.m_LayerOutput = &constantTensor;
7619 armnn::WorkloadInfo info;
7620 AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
7622 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConstant(descriptor, info);
7624 outputHandle->Allocate();
7626 workload->PostAllocationConfigure();
7627 workload->Execute();
7629 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
7633 LayerTestResult<float, 4> ConstantTest(
7634 armnn::IWorkloadFactory& workloadFactory,
7635 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7637 return ConstantTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager, 0.0f, 0);
7640 LayerTestResult<int16_t, 4> ConstantInt16SimpleQuantizationScaleNoOffsetTest(
7641 armnn::IWorkloadFactory& workloadFactory,
7642 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7644 return ConstantTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 1.0f, 0);
7647 LayerTestResult<uint8_t, 4> ConstantUint8SimpleQuantizationScaleNoOffsetTest(
7648 armnn::IWorkloadFactory& workloadFactory,
7649 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7651 return ConstantTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 1.0f, 0);
7654 LayerTestResult<uint8_t, 3> ConcatUint8DifferentQParamsTest(
7655 armnn::IWorkloadFactory& workloadFactory,
7656 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7658 unsigned int outputWidth = 3;
7659 unsigned int outputHeight = 6;
7660 unsigned int outputChannels = 3;
7662 unsigned int inputWidth1 = 3;
7663 unsigned int inputHeight1 = 6;
7664 unsigned int inputChannels1 = 2;
7666 unsigned int inputWidth2 = 3;
7667 unsigned int inputHeight2 = 6;
7668 unsigned int inputChannels2 = 1;
7670 // Defines the tensor descriptors.
7671 armnn::TensorInfo outputTensorInfo({ outputChannels, outputHeight, outputWidth }, armnn::DataType::QuantisedAsymm8);
7672 armnn::TensorInfo inputTensorInfo1({ inputChannels1, inputHeight1, inputWidth1 }, armnn::DataType::QuantisedAsymm8);
7673 armnn::TensorInfo inputTensorInfo2({ inputChannels2, inputHeight2, inputWidth2 }, armnn::DataType::QuantisedAsymm8);
7675 // Quantized input1 tensor. Range [-3, 1]
7676 const float inputScale1 = 0.015686f;
7677 const int32_t inputOffset1 = 192;
7679 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
7697 // Quatized input2 tensor. Range [-1, 4]
7698 const float inputScale2 = 0.019608f;
7699 const int32_t inputOffset2 = 50;
7701 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
7712 // Output has the same quantization parameters than input1,
7713 // so that only the requantization of input2 is required
7714 const float outputScale = 0.015686f;
7715 const int32_t outputOffset = 192;
7717 LayerTestResult<uint8_t, 3> ret(outputTensorInfo);
7719 ret.outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
7744 outputTensorInfo.SetQuantizationScale(outputScale);
7745 outputTensorInfo.SetQuantizationOffset(outputOffset);
7746 inputTensorInfo1.SetQuantizationScale(inputScale1);
7747 inputTensorInfo1.SetQuantizationOffset(inputOffset1);
7748 inputTensorInfo2.SetQuantizationScale(inputScale2);
7749 inputTensorInfo2.SetQuantizationOffset(inputOffset2);
7751 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
7752 armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
7754 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
7755 armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
7757 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
7759 bool subTensorsSupported = workloadFactory.SupportsSubTensors();
7761 std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
7762 subTensorsSupported ?
7763 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
7764 workloadFactory.CreateTensorHandle(inputTensorInfo1);
7766 std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
7767 subTensorsSupported ?
7768 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
7769 workloadFactory.CreateTensorHandle(inputTensorInfo2);
7771 armnn::ConcatQueueDescriptor data;
7772 armnn::WorkloadInfo info;
7773 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
7774 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
7775 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
7777 data.m_ViewOrigins.push_back(window1);
7778 data.m_ViewOrigins.push_back(window2);
7780 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
7782 inputHandle1->Allocate();
7783 inputHandle2->Allocate();
7784 outputHandle->Allocate();
7786 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
7787 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
7789 workload->PostAllocationConfigure();
7790 workload->Execute();
7792 CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
7797 LayerTestResult<uint8_t, 3> ConcatUint8Test(
7798 armnn::IWorkloadFactory& workloadFactory,
7799 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7801 unsigned int outputWidth = 3;
7802 unsigned int outputHeight = 6;
7803 unsigned int outputChannels = 3;
7805 unsigned int inputWidth1 = 3;
7806 unsigned int inputHeight1 = 6;
7807 unsigned int inputChannels1 = 2;
7809 unsigned int inputWidth2 = 3;
7810 unsigned int inputHeight2 = 6;
7811 unsigned int inputChannels2 = 1;
7813 // Defines the tensor descriptors.
7814 armnn::TensorInfo outputTensorInfo({ outputChannels, outputHeight, outputWidth }, armnn::DataType::QuantisedAsymm8);
7815 armnn::TensorInfo inputTensorInfo1({ inputChannels1, inputHeight1, inputWidth1 }, armnn::DataType::QuantisedAsymm8);
7816 armnn::TensorInfo inputTensorInfo2({ inputChannels2, inputHeight2, inputWidth2 }, armnn::DataType::QuantisedAsymm8);
7818 // Arbitrary scale and offsets. They don't really matter as the Concat operator doesn't dequantize/quantize them.
7819 const float scale = 0.13497836f;
7820 const int32_t offset = -7;
7822 outputTensorInfo.SetQuantizationScale(scale);
7823 outputTensorInfo.SetQuantizationOffset(offset);
7824 inputTensorInfo1.SetQuantizationScale(scale);
7825 inputTensorInfo1.SetQuantizationOffset(offset);
7826 inputTensorInfo2.SetQuantizationScale(scale);
7827 inputTensorInfo2.SetQuantizationOffset(offset);
7829 LayerTestResult<uint8_t, 3> ret(outputTensorInfo);
7831 ret.outputExpected = MakeTensor<uint8_t, 3>(outputTensorInfo, std::vector<uint8_t>(
7856 auto input1 = MakeTensor<uint8_t, 3>(inputTensorInfo1, std::vector<uint8_t>(
7874 auto input2 = MakeTensor<uint8_t, 3>(inputTensorInfo2, std::vector<uint8_t>(
7885 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
7886 armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
7888 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
7889 armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
7892 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
7894 bool subTensorsSupported = workloadFactory.SupportsSubTensors();
7896 std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
7897 subTensorsSupported ?
7898 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
7899 workloadFactory.CreateTensorHandle(inputTensorInfo1);
7901 std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
7902 subTensorsSupported ?
7903 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
7904 workloadFactory.CreateTensorHandle(inputTensorInfo2);
7907 armnn::ConcatQueueDescriptor data;
7908 armnn::WorkloadInfo info;
7909 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
7910 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
7911 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
7913 data.m_ViewOrigins.push_back(window1);
7914 data.m_ViewOrigins.push_back(window2);
7916 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
7918 inputHandle1->Allocate();
7919 inputHandle2->Allocate();
7920 outputHandle->Allocate();
7922 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
7923 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
7925 workload->PostAllocationConfigure();
7926 workload->Execute();
7928 CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
7933 LayerTestResult<uint16_t, 3> ConcatUint16Test(
7934 armnn::IWorkloadFactory& workloadFactory,
7935 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
7937 unsigned int outputWidth = 3;
7938 unsigned int outputHeight = 6;
7939 unsigned int outputChannels = 3;
7941 unsigned int inputWidth1 = 3;
7942 unsigned int inputHeight1 = 6;
7943 unsigned int inputChannels1 = 2;
7945 unsigned int inputWidth2 = 3;
7946 unsigned int inputHeight2 = 6;
7947 unsigned int inputChannels2 = 1;
7949 // Defines the tensor descriptors.
7950 armnn::TensorInfo outputTensorInfo({ outputChannels, outputHeight, outputWidth }, armnn::DataType::QuantisedSymm16);
7951 armnn::TensorInfo inputTensorInfo1({ inputChannels1, inputHeight1, inputWidth1 }, armnn::DataType::QuantisedSymm16);
7952 armnn::TensorInfo inputTensorInfo2({ inputChannels2, inputHeight2, inputWidth2 }, armnn::DataType::QuantisedSymm16);
7954 // Arbitrary scale and offsets. They don't really matter as the Concat operator doesn't dequantize/quantize them.
7955 const float scale = 0.13497836f;
7956 const int32_t offset = -7;
7958 outputTensorInfo.SetQuantizationScale(scale);
7959 outputTensorInfo.SetQuantizationOffset(offset);
7960 inputTensorInfo1.SetQuantizationScale(scale);
7961 inputTensorInfo1.SetQuantizationOffset(offset);
7962 inputTensorInfo2.SetQuantizationScale(scale);
7963 inputTensorInfo2.SetQuantizationOffset(offset);
7965 LayerTestResult<uint16_t, 3> ret(outputTensorInfo);
7967 ret.outputExpected = MakeTensor<uint16_t, 3>(outputTensorInfo, std::vector<uint16_t>(
7991 auto input1 = MakeTensor<uint16_t, 3>(inputTensorInfo1, std::vector<uint16_t>(
8008 auto input2 = MakeTensor<uint16_t, 3>(inputTensorInfo2, std::vector<uint16_t>(
8018 std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
8019 armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
8021 std::vector<unsigned int> wOrigin2 = { 2, 0, 0 }; //Extent of the window is defined by size of input[1].
8022 armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
8025 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
8027 bool subTensorsSupported = workloadFactory.SupportsSubTensors();
8029 std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
8030 subTensorsSupported ?
8031 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
8032 workloadFactory.CreateTensorHandle(inputTensorInfo1);
8034 std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
8035 subTensorsSupported ?
8036 workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
8037 workloadFactory.CreateTensorHandle(inputTensorInfo2);
8040 armnn::ConcatQueueDescriptor data;
8041 armnn::WorkloadInfo info;
8042 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
8043 AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
8044 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
8046 data.m_ViewOrigins.push_back(window1);
8047 data.m_ViewOrigins.push_back(window2);
8049 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
8051 inputHandle1->Allocate();
8052 inputHandle2->Allocate();
8053 outputHandle->Allocate();
8055 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
8056 CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
8058 workload->PostAllocationConfigure();
8059 workload->Execute();
8061 CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
8068 template <typename T>
8069 LayerTestResult<T, 4> AdditionQuantizeTestHelper(
8070 armnn::IWorkloadFactory& workloadFactory,
8071 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
8072 const unsigned int shape0[4],
8073 const std::vector<T>& values0,
8076 const unsigned int shape1[4],
8077 const std::vector<T> & values1,
8080 const unsigned int outShape[4],
8081 const std::vector<T> & outValues,
8085 auto dataType = (std::is_same<T, uint8_t>::value ?
8086 armnn::DataType::QuantisedAsymm8 :
8087 armnn::DataType::QuantisedSymm16);
8089 armnn::TensorInfo inputTensorInfo0(4, shape0, dataType);
8090 armnn::TensorInfo inputTensorInfo1(4, shape1, dataType);
8091 armnn::TensorInfo outputTensorInfo(4, outShape, dataType);
8093 inputTensorInfo0.SetQuantizationScale(scale0);
8094 inputTensorInfo0.SetQuantizationOffset(offset0);
8096 inputTensorInfo1.SetQuantizationScale(scale1);
8097 inputTensorInfo1.SetQuantizationOffset(offset1);
8099 outputTensorInfo.SetQuantizationScale(outScale);
8100 outputTensorInfo.SetQuantizationOffset(outOffset);
8102 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, values0);
8103 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, values1);
8105 LayerTestResult<T, 4> result(outputTensorInfo);
8106 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outValues);
8108 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
8109 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
8110 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
8112 armnn::AdditionQueueDescriptor data;
8113 armnn::WorkloadInfo info;
8114 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
8115 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
8116 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
8118 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateAddition(data, info);
8120 inputHandle0->Allocate();
8121 inputHandle1->Allocate();
8122 outputHandle->Allocate();
8124 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
8125 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
8127 workload->PostAllocationConfigure();
8128 workload->Execute();
8130 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
8134 } // anonymous namespace
8136 LayerTestResult<uint8_t, 4> AdditionUint8Test(
8137 armnn::IWorkloadFactory& workloadFactory,
8138 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8140 const unsigned int shape0[] = { 1, 2, 2, 3 };
8141 const unsigned int shape1[] = { 1, 2, 2, 3 };
8143 std::vector<uint8_t> input0(
8145 63, 35, 77, 70, 56, 112, // 420, 224, 518, 469, 371, 763
8146 203, 28, 252, 168, 245, 91 // 1400, 175, 1743, 1155, 1694, 616
8149 std::vector<uint8_t> input1(
8151 21, 7, 175, 231, 175, 210, // 126, 28, 1204, 1596, 1204, 1449
8152 126, 161, 63, 21, 105, 126 // 861, 1106, 420, 126, 714, 861
8155 std::vector<uint8_t> output(
8157 81, 39, 249, 255, 228, 255, // 546, 252, 1722, 2065(clamped), 1575, 2212(clamped)
8158 255, 186, 255, 186, 255, 214, // 2261(clamped), 1281, 2163(clamped), 1281, 2408(clamped), 1477
8161 return AdditionQuantizeTestHelper(workloadFactory,
8163 shape0, input0, 7.0f, 3,
8164 shape1, input1, 7.0f, 3,
8165 shape0, output, 7.0f, 3);
8168 LayerTestResult<int16_t, 4> AdditionInt16Test(
8169 armnn::IWorkloadFactory& workloadFactory,
8170 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8172 const unsigned int shape0[] = { 1, 2, 2, 3 };
8173 const unsigned int shape1[] = { 1, 2, 2, 3 };
8175 std::vector<int16_t> input0(
8177 63, 35, 77, 70, 56, 112, // 441, 245, 539, 490, 392, 184
8178 203, 28, 252, 168, 245, 91 // 1421, 196, 1764, 1176, 1715, 637
8181 std::vector<int16_t> input1(
8183 21, 7, 175, 231, 175, 210, // 126, 28, 1204, 1596, 1204, 1449
8184 126, 161, 63, 21, 105, 126 // 861, 1106, 420, 126, 714, 861
8187 std::vector<int16_t> output(
8189 84, 42, 252, 301, 231, 322, // 588, 294, 1764, 2107(clamped), 1617, 2254(clamped)
8190 329, 189, 315, 189, 350, 217, // 2303(clamped), 1323, 2205(clamped), 1323, 2450(clamped), 1519
8193 return AdditionQuantizeTestHelper(workloadFactory,
8195 shape0, input0, 7.0f, 0,
8196 shape1, input1, 7.0f, 0,
8197 shape0, output, 7.0f, 0);
8202 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
8203 LayerTestResult<T, 4> MultiplicationQuantizeTestHelper(
8204 armnn::IWorkloadFactory& workloadFactory,
8205 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
8206 const unsigned int shape0[4],
8207 const std::vector<T> & values0,
8210 const unsigned int shape1[4],
8211 const std::vector<T> & values1,
8214 const unsigned int outShape[4],
8215 const std::vector<T> & outValues,
8219 armnn::TensorInfo inputTensorInfo0(4, shape0, ArmnnType);
8220 armnn::TensorInfo inputTensorInfo1(4, shape1, ArmnnType);
8221 armnn::TensorInfo outputTensorInfo(4, outShape, ArmnnType);
8223 inputTensorInfo0.SetQuantizationScale(scale0);
8224 inputTensorInfo0.SetQuantizationOffset(offset0);
8226 inputTensorInfo1.SetQuantizationScale(scale1);
8227 inputTensorInfo1.SetQuantizationOffset(offset1);
8229 outputTensorInfo.SetQuantizationScale(outScale);
8230 outputTensorInfo.SetQuantizationOffset(outOffset);
8232 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, values0);
8233 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, values1);
8235 LayerTestResult<T, 4> result(outputTensorInfo);
8236 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outValues);
8238 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
8239 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
8240 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
8242 armnn::MultiplicationQueueDescriptor data;
8243 armnn::WorkloadInfo info;
8244 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
8245 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
8246 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
8248 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateMultiplication(data, info);
8250 inputHandle0->Allocate();
8251 inputHandle1->Allocate();
8252 outputHandle->Allocate();
8254 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
8255 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
8257 workload->PostAllocationConfigure();
8258 workload->Execute();
8260 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
8264 } // anonymous namespace
8266 LayerTestResult<uint8_t, 4> MultiplicationUint8Test(
8267 armnn::IWorkloadFactory& workloadFactory,
8268 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8270 unsigned int batchSize = 1;
8271 unsigned int channels = 2;
8272 unsigned int height = 2;
8273 unsigned int width = 3;
8274 const unsigned int shape[] = { batchSize, channels, height, width };
8276 // See dequantized values to the right.
8277 std::vector<uint8_t> input0({
8278 62, 37, 3, 172, 13, 111, // 244, 144, 8, 684, 48, 440,
8279 188, 20, 73, 31, 23, 31 // 748, 76, 288, 120, 88, 120
8282 // See dequantized values to the right.
8283 std::vector<uint8_t> input1({
8284 126, 240, 252, 183, 121, 247, // 384, 726, 762, 555, 369, 747,
8285 48, 115, 151, 79, 78, 97 // 150, 351, 459, 243, 240, 297
8288 // See dequantized values to the right.
8289 std::vector<uint8_t> output(
8291 64, 72, 0, 255, 8, 236, // 93696, 104544, 6096(clamped), 379620(clamped), 17712, 328680,
8292 77, 15, 92, 16, 10, 21, // 112200, 26676, 132192, 29160, 21120, 35640
8295 // Scale/offset chosen to have output values out of range.
8296 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8312 LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(
8313 armnn::IWorkloadFactory& workloadFactory,
8314 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8316 const unsigned int shape0[] = { 1, 2, 2, 3 };
8317 const unsigned int shape1[] = { 1, 1, 1, 1 };
8319 std::vector<uint8_t> input0({
8324 std::vector<uint8_t> input1({2});
8326 std::vector<uint8_t> output({
8328 14, 16, 18, 20, 22, 24
8331 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8347 LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(
8348 armnn::IWorkloadFactory& workloadFactory,
8349 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8351 const unsigned int shape0[] = { 1, 2, 2, 3 };
8352 const unsigned int shape1[] = { 1, 1, 1, 3 };
8354 std::vector<uint8_t> input0({
8359 std::vector<uint8_t> input1({1, 2, 3});
8361 std::vector<uint8_t> output({
8363 7, 16, 27, 10, 22, 36
8366 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8382 LayerTestResult<int16_t, 4> MultiplicationInt16Test(
8383 armnn::IWorkloadFactory& workloadFactory,
8384 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8386 const unsigned int shape[] = { 1, 2, 2, 3 };
8388 std::vector<int16_t> input0(
8391 12, 13, 14, 15, 16, 17
8394 std::vector<int16_t> input1(
8400 std::vector<int16_t> output(
8402 6, 14, 24, 36, 50, 66,
8403 84, 104, 126, 150, 176, 204
8406 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8422 LayerTestResult<int16_t, 4> MultiplicationBroadcast1ElementInt16Test(
8423 armnn::IWorkloadFactory& workloadFactory,
8424 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8426 const unsigned int shape0[] = { 1, 2, 2, 3 };
8427 const unsigned int shape1[] = { 1, 1, 1, 1 };
8429 std::vector<int16_t> input0(
8435 std::vector<int16_t> input1({2});
8437 std::vector<int16_t> output(
8440 14, 16, 18, 20, 22, 24
8443 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8459 LayerTestResult<int16_t, 4> MultiplicationBroadcast1DVectorInt16Test(
8460 armnn::IWorkloadFactory& workloadFactory,
8461 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8463 const unsigned int shape0[] = { 1, 2, 2, 3 };
8464 const unsigned int shape1[] = { 1, 1, 1, 3 };
8466 std::vector<int16_t> input0(
8472 std::vector<int16_t> input1({1, 2, 3});
8474 std::vector<int16_t> output(
8477 7, 16, 27, 10, 22, 36
8480 return MultiplicationQuantizeTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8498 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
8499 LayerTestResult<T, 4> SubtractionTestHelper(
8500 armnn::IWorkloadFactory& workloadFactory,
8501 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
8502 const unsigned int shape0[4],
8503 const std::vector<T>& values0,
8506 const unsigned int shape1[4],
8507 const std::vector<T> & values1,
8510 const unsigned int outShape[4],
8511 const std::vector<T> & outValues,
8515 armnn::TensorInfo inputTensorInfo0(4, shape0, ArmnnType);
8516 armnn::TensorInfo inputTensorInfo1(4, shape1, ArmnnType);
8517 armnn::TensorInfo outputTensorInfo(4, outShape, ArmnnType);
8519 inputTensorInfo0.SetQuantizationScale(scale0);
8520 inputTensorInfo0.SetQuantizationOffset(offset0);
8522 inputTensorInfo1.SetQuantizationScale(scale1);
8523 inputTensorInfo1.SetQuantizationOffset(offset1);
8525 outputTensorInfo.SetQuantizationScale(outScale);
8526 outputTensorInfo.SetQuantizationOffset(outOffset);
8528 auto input0 = MakeTensor<T, 4>(inputTensorInfo0, values0);
8529 auto input1 = MakeTensor<T, 4>(inputTensorInfo1, values1);
8531 LayerTestResult<T, 4> result(outputTensorInfo);
8532 result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outValues);
8534 std::unique_ptr<armnn::ITensorHandle> inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0);
8535 std::unique_ptr<armnn::ITensorHandle> inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1);
8536 std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
8538 armnn::SubtractionQueueDescriptor data;
8539 armnn::WorkloadInfo info;
8540 AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get());
8541 AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
8542 AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
8544 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateSubtraction(data, info);
8546 inputHandle0->Allocate();
8547 inputHandle1->Allocate();
8548 outputHandle->Allocate();
8550 CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]);
8551 CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]);
8553 workload->PostAllocationConfigure();
8554 workload->Execute();
8556 CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
8560 } // anonymous namespace
8562 LayerTestResult<uint8_t, 4> SubtractionUint8Test(
8563 armnn::IWorkloadFactory& workloadFactory,
8564 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8566 const unsigned int shape0[] = { 1, 1, 2, 2 };
8567 const unsigned int shape1[] = { 1, 1, 2, 2 };
8569 std::vector<uint8_t> input0({ 10, 12, 14, 16 });
8570 std::vector<uint8_t> input1({ 1, 2, 1, 2 });
8571 std::vector<uint8_t> output({ 3, 3, 5, 5 });
8573 return SubtractionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8575 shape0, input0, 0.5f, 2,
8576 shape1, input1, 1.0f, 0,
8577 shape0, output, 1.0f, 0);
8580 LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(
8581 armnn::IWorkloadFactory& workloadFactory,
8582 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8584 const unsigned int shape0[] = { 1, 1, 2, 2 };
8585 const unsigned int shape1[] = { 1, 1, 1, 1 };
8587 std::vector<uint8_t> input0({ 10, 12, 14, 16 });
8588 std::vector<uint8_t> input1({ 2 });
8589 std::vector<uint8_t> output({ 5, 6, 7, 8 });
8591 return SubtractionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8593 shape0, input0, 0.5f, 2,
8594 shape1, input1, 1.0f, 0,
8595 shape0, output, 1.0f, 3);
8598 LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(
8599 armnn::IWorkloadFactory& workloadFactory,
8600 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8602 const unsigned int shape0[] = { 1, 1, 2, 2 };
8603 const unsigned int shape1[] = { 1, 1, 2, 1 };
8605 std::vector<uint8_t> input0({ 10, 12, 14, 16 });
8606 std::vector<uint8_t> input1({ 2, 1 });
8607 std::vector<uint8_t> output({ 8, 11, 12, 15 });
8609 return SubtractionTestHelper<armnn::DataType::QuantisedAsymm8>(workloadFactory,
8611 shape0, input0, 1.0f, 0,
8612 shape1, input1, 1.0f, 0,
8613 shape0, output, 1.0f, 0);
8616 LayerTestResult<float, 4> SubtractionTest(
8617 armnn::IWorkloadFactory& workloadFactory,
8618 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8620 const unsigned int shape0[] = { 1, 1, 2, 2 };
8621 const unsigned int shape1[] = { 1, 1, 2, 2 };
8623 std::vector<float> input0({ 1, 2, 3, 4 });
8624 std::vector<float> input1({ 1, -1, 0, 2 });
8625 std::vector<float> output({ 0, 3, 3, 2 });
8627 return SubtractionTestHelper<armnn::DataType::Float32>(workloadFactory,
8629 shape0, input0, 1.0f, 0,
8630 shape1, input1, 1.0f, 0,
8631 shape0, output, 1.0f, 0);
8634 LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(
8635 armnn::IWorkloadFactory& workloadFactory,
8636 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8638 const unsigned int shape0[] = { 1, 1, 2, 2 };
8639 const unsigned int shape1[] = { 1, 1, 1, 1 };
8641 std::vector<float> input0({ 1, 2, 3, 4 });
8642 std::vector<float> input1({ 10 });
8643 std::vector<float> output({ -9, -8, -7, -6 });
8645 return SubtractionTestHelper<armnn::DataType::Float32>(workloadFactory,
8647 shape0, input0, 1.0f, 0,
8648 shape1, input1, 1.0f, 0,
8649 shape0, output, 1.0f, 0);
8652 LayerTestResult<float, 4> SubtractionBroadcastTest(
8653 armnn::IWorkloadFactory& workloadFactory,
8654 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8656 const unsigned int shape0[] = { 1, 1, 2, 2 };
8657 const unsigned int shape1[] = { 1, 1, 1, 2 };
8659 std::vector<float> input0({ 1, 2, 3, 4 });
8660 std::vector<float> input1({ 10, -5 });
8661 std::vector<float> output({ -9, 7, -7, 9 });
8663 return SubtractionTestHelper<armnn::DataType::Float32>(workloadFactory,
8665 shape0, input0, 1.0f, 0,
8666 shape1, input1, 1.0f, 0,
8667 shape0, output, 1.0f, 0);
8670 LayerTestResult<int16_t, 4> SubtractionInt16Test(
8671 armnn::IWorkloadFactory& workloadFactory,
8672 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8674 const unsigned int shape0[] = { 1, 1, 2, 2 };
8675 const unsigned int shape1[] = { 1, 1, 2, 2 };
8677 std::vector<int16_t> input0({ 10, 12, 14, 16 });
8678 std::vector<int16_t> input1({ 1, 2, 1, 2 });
8679 std::vector<int16_t> output({ 3, 3, 5, 5 });
8681 return SubtractionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8683 shape0, input0, 0.5f, 0,
8684 shape1, input1, 1.0f, 0,
8685 shape0, output, 1.0f, 0);
8688 LayerTestResult<int16_t, 4> SubtractionBroadcast1ElementInt16Test(
8689 armnn::IWorkloadFactory& workloadFactory,
8690 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8692 const unsigned int shape0[] = { 1, 1, 2, 2 };
8693 const unsigned int shape1[] = { 1, 1, 1, 1 };
8695 std::vector<int16_t> input0({ 10, 12, 14, 16 });
8696 std::vector<int16_t> input1({ 2 });
8697 std::vector<int16_t> output({ 3, 4, 5, 6 });
8699 return SubtractionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8701 shape0, input0, 0.5f, 0,
8702 shape1, input1, 1.0f, 0,
8703 shape0, output, 1.0f, 0);
8706 LayerTestResult<int16_t, 4> SubtractionBroadcastInt16Test(
8707 armnn::IWorkloadFactory& workloadFactory,
8708 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8710 const unsigned int shape0[] = { 1, 1, 2, 2 };
8711 const unsigned int shape1[] = { 1, 1, 2, 1 };
8713 std::vector<int16_t> input0({ 10, 12, 14, 16 });
8714 std::vector<int16_t> input1({ 2, 1 });
8715 std::vector<int16_t> output({ 8, 11, 12, 15 });
8717 return SubtractionTestHelper<armnn::DataType::QuantisedSymm16>(workloadFactory,
8719 shape0, input0, 1.0f, 0,
8720 shape1, input1, 1.0f, 0,
8721 shape0, output, 1.0f, 0);
8724 LayerTestResult<float, 4> BatchNormTest(
8725 armnn::IWorkloadFactory& workloadFactory,
8726 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8733 const armnn::TensorShape inputOutputShape{ 1, 2, 3, 2 };
8734 std::vector<float> inputValues
8736 // Batch 0, Channel 0, Height (3) x Width (2)
8741 // Batch 0, Channel 1, Height (3) x Width (2)
8746 std::vector<float> expectedOutputValues
8748 // Batch 0, Channel 0, Height (3) x Width (2)
8753 // Batch 0, Channel 1, Height (3) x Width (2)
8759 return BatchNormTestImpl<armnn::DataType::Float32>(
8760 workloadFactory, memoryManager,
8761 inputOutputShape, inputValues, expectedOutputValues,
8762 0.f, 0, armnn::DataLayout::NCHW);
8765 LayerTestResult<float, 4> BatchNormNhwcTest(
8766 armnn::IWorkloadFactory& workloadFactory,
8767 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8774 const armnn::TensorShape inputOutputShape{ 1, 3, 2, 2 };
8775 std::vector<float> inputValues
8777 // Batch 0, Height 0, Width (2) x Channel (2)
8781 // Batch 0, Height 1, Width (2) x Channel (2)
8785 // Batch 0, Height 2, Width (2) x Channel (2)
8789 std::vector<float> expectedOutputValues
8791 // Batch 0, Height 0, Width (2) x Channel (2)
8795 // Batch 0, Height 1, Width (2) x Channel (2)
8799 // Batch 0, Height 2, Width (2) x Channel (2)
8804 return BatchNormTestImpl<armnn::DataType::Float32>(
8805 workloadFactory, memoryManager,
8806 inputOutputShape, inputValues, expectedOutputValues,
8807 0.f, 0, armnn::DataLayout::NHWC);
8810 LayerTestResult<uint8_t, 4> BatchNormUint8Test(
8811 armnn::IWorkloadFactory& workloadFactory,
8812 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8819 const armnn::TensorShape inputOutputShape{ 1, 2, 3, 2 };
8820 std::vector<float> inputValues
8822 // Batch 0, Channel 0, Height (3) x Width (2)
8827 // Batch 0, Channel 1, Height (3) x Width (2)
8832 std::vector<float> expectedOutputValues
8834 // Batch 0, Channel 0, Height (3) x Width (2)
8839 // Batch 0, Channel 1, Height (3) x Width (2)
8845 return BatchNormTestImpl<armnn::DataType::QuantisedAsymm8>(
8846 workloadFactory, memoryManager,
8847 inputOutputShape, inputValues, expectedOutputValues,
8848 1.f/20.f, 50, armnn::DataLayout::NCHW);
8851 LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(
8852 armnn::IWorkloadFactory& workloadFactory,
8853 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8860 const armnn::TensorShape inputOutputShape{ 1, 3, 2, 2 };
8861 std::vector<float> inputValues
8863 // Batch 0, Height 0, Width (2) x Channel (2)
8867 // Batch 0, Height 1, Width (2) x Channel (2)
8871 // Batch 0, Height 2, Width (2) x Channel (2)
8875 std::vector<float> expectedOutputValues
8877 // Batch 0, Height 0, Width (2) x Channel (2)
8881 // Batch 0, Height 1, Width (2) x Channel (2)
8885 // Batch 0, Height 2, Width (2) x Channel (2)
8890 return BatchNormTestImpl<armnn::DataType::QuantisedAsymm8>
8891 (workloadFactory, memoryManager,
8892 inputOutputShape, inputValues, expectedOutputValues,
8893 1.f/20.f, 50, armnn::DataLayout::NHWC);
8896 LayerTestResult<int16_t, 4> BatchNormInt16Test(
8897 armnn::IWorkloadFactory& workloadFactory,
8898 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8905 const armnn::TensorShape inputOutputShape{ 1, 2, 3, 2 };
8906 std::vector<float> inputValues
8908 // Batch 0, Channel 0, Height (3) x Width (2)
8913 // Batch 0, Channel 1, Height (3) x Width (2)
8918 std::vector<float> expectedOutputValues
8920 // Batch 0, Channel 0, Height (3) x Width (2)
8925 // Batch 0, Channel 1, Height (3) x Width (2)
8931 return BatchNormTestImpl<armnn::DataType::QuantisedSymm16>(
8932 workloadFactory, memoryManager,
8933 inputOutputShape, inputValues, expectedOutputValues,
8934 1.f/20.f, 50, armnn::DataLayout::NCHW);
8937 LayerTestResult<int16_t, 4> BatchNormInt16NhwcTest(
8938 armnn::IWorkloadFactory& workloadFactory,
8939 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8946 const armnn::TensorShape inputOutputShape{ 1, 3, 2, 2 };
8947 std::vector<float> inputValues
8949 // Batch 0, Height 0, Width (2) x Channel (2)
8953 // Batch 0, Height 1, Width (2) x Channel (2)
8957 // Batch 0, Height 2, Width (2) x Channel (2)
8961 std::vector<float> expectedOutputValues
8963 // Batch 0, Height 0, Width (2) x Channel (2)
8967 // Batch 0, Height 1, Width (2) x Channel (2)
8971 // Batch 0, Height 2, Width (2) x Channel (2)
8976 return BatchNormTestImpl<armnn::DataType::QuantisedSymm16>
8977 (workloadFactory, memoryManager,
8978 inputOutputShape, inputValues, expectedOutputValues,
8979 1.f/20.f, 50, armnn::DataLayout::NHWC);
8982 LayerTestResult<uint8_t, 4> ConstantUint8CustomQuantizationScaleAndOffsetTest(
8983 armnn::IWorkloadFactory& workloadFactory,
8984 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8986 return ConstantTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 2e-6f, 1);
8989 LayerTestResult<int16_t, 4> ConstantInt16CustomQuantizationScaleAndOffsetTest(
8990 armnn::IWorkloadFactory& workloadFactory,
8991 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
8993 return ConstantTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, 2e-6f, 1);
8996 LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(
8997 armnn::IWorkloadFactory& workloadFactory,
8998 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9000 return Concatenation1dTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9003 LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(
9004 armnn::IWorkloadFactory& workloadFactory,
9005 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9007 return Concatenation2dDim0TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9010 LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(
9011 armnn::IWorkloadFactory& workloadFactory,
9012 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9014 return Concatenation2dDim1TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9017 LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(
9018 armnn::IWorkloadFactory& workloadFactory,
9019 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9021 return Concatenation2dDim0DiffInputDimsTestImpl<armnn::DataType::QuantisedAsymm8>(
9022 workloadFactory, memoryManager, 0.5f, -1);
9025 LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(
9026 armnn::IWorkloadFactory& workloadFactory,
9027 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9029 return Concatenation2dDim1DiffInputDimsTestImpl<armnn::DataType::QuantisedAsymm8>(
9030 workloadFactory, memoryManager, 0.5f, -1);
9033 LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(
9034 armnn::IWorkloadFactory& workloadFactory,
9035 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9037 return Concatenation3dDim0TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9040 LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(
9041 armnn::IWorkloadFactory& workloadFactory,
9042 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9044 return Concatenation3dDim1TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9047 LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(
9048 armnn::IWorkloadFactory& workloadFactory,
9049 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9052 return Concatenation3dDim2TestImpl<armnn::DataType::QuantisedAsymm8>(
9053 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
9056 LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(
9057 armnn::IWorkloadFactory& workloadFactory,
9058 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9060 return Concatenation3dDim0TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9063 LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(
9064 armnn::IWorkloadFactory& workloadFactory,
9065 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9067 return Concatenation3dDim1DiffInputDimsTestImpl<armnn::DataType::QuantisedAsymm8>(
9068 workloadFactory, memoryManager, 0.5f, -1);
9071 LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(
9072 armnn::IWorkloadFactory& workloadFactory,
9073 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9076 return Concatenation3dDim2DiffInputDimsTestImpl<armnn::DataType::QuantisedAsymm8>(
9077 workloadFactory, memoryManager, useSubtensor, 0.5f, -1);
9080 LayerTestResult<uint8_t, 4> Concatenation4dDim0Uint8Test(
9081 armnn::IWorkloadFactory& workloadFactory,
9082 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9084 return Concatenation4dDim0TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9087 LayerTestResult<uint8_t, 4> Concatenation4dDim1Uint8Test(
9088 armnn::IWorkloadFactory& workloadFactory,
9089 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9091 return Concatenation4dDim1TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9094 LayerTestResult<uint8_t, 4> Concatenation4dDim2Uint8Test(
9095 armnn::IWorkloadFactory& workloadFactory,
9096 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9098 return Concatenation4dDim2TestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, 0.5f, -1);
9101 LayerTestResult<uint8_t, 4> Concatenation4dDim3Uint8Test(
9102 armnn::IWorkloadFactory& workloadFactory,
9103 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, bool useSubtensor)
9105 return Concatenation4dDim3TestImpl<armnn::DataType::QuantisedAsymm8>(
9106 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
9109 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim0Uint8Test(
9110 armnn::IWorkloadFactory& workloadFactory,
9111 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9113 return Concatenation4dDiffShapeDim0TestImpl<armnn::DataType::QuantisedAsymm8>(
9114 workloadFactory, memoryManager, 0.5f, -1);
9117 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim1Uint8Test(
9118 armnn::IWorkloadFactory& workloadFactory,
9119 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9121 return Concatenation4dDiffShapeDim1TestImpl<armnn::DataType::QuantisedAsymm8>(
9122 workloadFactory, memoryManager, 0.5f, -1);
9125 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim2Uint8Test(
9126 armnn::IWorkloadFactory& workloadFactory,
9127 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9129 return Concatenation4dDiffShapeDim2TestImpl<armnn::DataType::QuantisedAsymm8>(
9130 workloadFactory, memoryManager, 0.5f, -1);
9133 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim3Uint8Test(
9134 armnn::IWorkloadFactory& workloadFactory,
9135 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9138 return Concatenation4dDiffShapeDim3TestImpl<armnn::DataType::QuantisedAsymm8>(
9139 workloadFactory, memoryManager, 0.5f, -1, useSubtensor);
9142 LayerTestResult<float, 4> SimpleMaxPooling2dSize2x2Stride2x2Test(
9143 armnn::IWorkloadFactory& workloadFactory,
9144 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9145 bool forceNoPadding)
9147 return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::Float32>(
9148 workloadFactory, memoryManager, forceNoPadding);
9151 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
9152 armnn::IWorkloadFactory& workloadFactory,
9153 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9154 bool forceNoPadding)
9156 return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::QuantisedAsymm8>(
9157 workloadFactory, memoryManager, forceNoPadding, 3.0f, -5);
9160 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Int16Test(
9161 armnn::IWorkloadFactory& workloadFactory,
9162 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9163 bool forceNoPadding)
9165 return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::QuantisedSymm16>(
9166 workloadFactory, memoryManager, forceNoPadding);
9169 LayerTestResult<float, 4> SimpleMaxPooling2dSize3x3Stride2x4Test(
9170 armnn::IWorkloadFactory& workloadFactory,
9171 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9172 bool forceNoPadding)
9174 return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::Float32>(
9175 workloadFactory, memoryManager, forceNoPadding);
9178 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
9179 armnn::IWorkloadFactory& workloadFactory,
9180 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9181 bool forceNoPadding)
9183 return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::QuantisedAsymm8>(
9184 workloadFactory, memoryManager, forceNoPadding, 0.1f, 128);
9187 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Int16Test(
9188 armnn::IWorkloadFactory& workloadFactory,
9189 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9190 bool forceNoPadding)
9192 return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::QuantisedSymm16>(
9193 workloadFactory, memoryManager, forceNoPadding);
9196 LayerTestResult<float, 4> SimpleMaxPooling2dTest(
9197 armnn::IWorkloadFactory& workloadFactory,
9198 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9199 const armnn::DataLayout dataLayout)
9201 return SimpleMaxPooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, dataLayout);
9204 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
9205 armnn::IWorkloadFactory& workloadFactory,
9206 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9207 const armnn::DataLayout dataLayout)
9209 return SimpleMaxPooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, dataLayout);
9212 LayerTestResult<int16_t, 4> SimpleMaxPooling2dInt16Test(
9213 armnn::IWorkloadFactory& workloadFactory,
9214 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9215 const armnn::DataLayout dataLayout)
9217 return SimpleMaxPooling2dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, dataLayout);
9219 LayerTestResult<float, 4> IgnorePaddingSimpleMaxPooling2dTest(
9220 armnn::IWorkloadFactory& workloadFactory,
9221 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9223 return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9226 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
9227 armnn::IWorkloadFactory& workloadFactory,
9228 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9230 return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(
9231 workloadFactory, memoryManager, 1.0f, -5);
9234 LayerTestResult<int16_t, 4> IgnorePaddingSimpleMaxPooling2dInt16Test(
9235 armnn::IWorkloadFactory& workloadFactory,
9236 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9238 return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::QuantisedSymm16>(
9239 workloadFactory, memoryManager);
9242 LayerTestResult<float, 4> IgnorePaddingMaxPooling2dSize3Test(
9243 armnn::IWorkloadFactory& workloadFactory,
9244 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9246 return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9249 LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
9250 armnn::IWorkloadFactory& workloadFactory,
9251 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9253 return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::QuantisedAsymm8>(
9254 workloadFactory, memoryManager, 1.0f, -5);
9257 LayerTestResult<int16_t, 4> IgnorePaddingMaxPooling2dSize3Int16Test(
9258 armnn::IWorkloadFactory& workloadFactory,
9259 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9261 return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::QuantisedSymm16>(
9262 workloadFactory, memoryManager);
9265 LayerTestResult<float, 4> SimpleAveragePooling2dTest(
9266 armnn::IWorkloadFactory& workloadFactory,
9267 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9268 const armnn::DataLayout dataLayout)
9270 return SimpleAveragePooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, dataLayout);
9273 LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
9274 armnn::IWorkloadFactory& workloadFactory,
9275 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9276 const armnn::DataLayout dataLayout)
9278 return SimpleAveragePooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(
9279 workloadFactory, memoryManager, dataLayout, 0.5, -1);
9282 LayerTestResult<int16_t, 4> SimpleAveragePooling2dInt16Test(
9283 armnn::IWorkloadFactory& workloadFactory,
9284 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9285 const armnn::DataLayout dataLayout)
9287 return SimpleAveragePooling2dTestCommon<armnn::DataType::QuantisedSymm16>(
9288 workloadFactory, memoryManager, dataLayout);
9291 LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
9292 armnn::IWorkloadFactory& workloadFactory,
9293 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9294 bool forceNoPadding)
9296 return IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon<armnn::DataType::Float32>(
9297 workloadFactory, memoryManager, forceNoPadding);
9300 LayerTestResult<float, 4> LargeTensorsAveragePooling2dTest(
9301 armnn::IWorkloadFactory& workloadFactory,
9302 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9304 return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9307 LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
9308 armnn::IWorkloadFactory& workloadFactory,
9309 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9311 return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(
9312 workloadFactory, memoryManager, 0.5, -1);
9315 LayerTestResult<int16_t, 4> LargeTensorsAveragePooling2dInt16Test(
9316 armnn::IWorkloadFactory& workloadFactory,
9317 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9319 return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::QuantisedSymm16>(
9320 workloadFactory, memoryManager);
9322 LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dTest(
9323 armnn::IWorkloadFactory& workloadFactory,
9324 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9326 return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9329 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
9330 armnn::IWorkloadFactory& workloadFactory,
9331 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9333 return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(
9334 workloadFactory, memoryManager);
9337 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dInt16Test(
9338 armnn::IWorkloadFactory& workloadFactory,
9339 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9341 return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::QuantisedSymm16>(
9342 workloadFactory, memoryManager);
9345 LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
9346 armnn::IWorkloadFactory& workloadFactory,
9347 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9349 return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::Float32>(
9350 workloadFactory, memoryManager);
9353 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
9354 armnn::IWorkloadFactory& workloadFactory,
9355 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9357 return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::QuantisedAsymm8>(
9358 workloadFactory, memoryManager);
9361 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test(
9362 armnn::IWorkloadFactory& workloadFactory,
9363 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9365 return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::QuantisedSymm16>(
9366 workloadFactory, memoryManager);
9369 LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3Test(
9370 armnn::IWorkloadFactory& workloadFactory,
9371 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9373 return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9376 LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
9377 armnn::IWorkloadFactory& workloadFactory,
9378 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9380 return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::QuantisedAsymm8>(
9381 workloadFactory, memoryManager);
9384 LayerTestResult<int16_t, 4> IgnorePaddingAveragePooling2dSize3Int16Test(
9385 armnn::IWorkloadFactory& workloadFactory,
9386 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9388 return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::QuantisedSymm16>(
9389 workloadFactory, memoryManager);
9392 LayerTestResult<float, 4> SimpleL2Pooling2dTest(
9393 armnn::IWorkloadFactory& workloadFactory,
9394 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9395 const armnn::DataLayout dataLayout)
9397 return SimpleL2Pooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, dataLayout);
9400 LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
9401 armnn::IWorkloadFactory& workloadFactory,
9402 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9403 const armnn::DataLayout dataLayout)
9405 return SimpleL2Pooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager, dataLayout);
9408 LayerTestResult<int16_t, 4> SimpleL2Pooling2dInt16Test(
9409 armnn::IWorkloadFactory& workloadFactory,
9410 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9411 const armnn::DataLayout dataLayout)
9413 return SimpleL2Pooling2dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager, dataLayout);
9416 LayerTestResult<float, 4> L2Pooling2dSize3Stride1Test(
9417 armnn::IWorkloadFactory& workloadFactory,
9418 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9420 return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9423 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
9424 armnn::IWorkloadFactory& workloadFactory,
9425 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9427 return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9430 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride1Int16Test(
9431 armnn::IWorkloadFactory& workloadFactory,
9432 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9434 return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9437 LayerTestResult<float, 4> L2Pooling2dSize3Stride3Test(
9438 armnn::IWorkloadFactory& workloadFactory,
9439 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9441 return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9444 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
9445 armnn::IWorkloadFactory& workloadFactory,
9446 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9448 return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9451 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride3Int16Test(
9452 armnn::IWorkloadFactory& workloadFactory,
9453 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9455 return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9457 LayerTestResult<float, 4> L2Pooling2dSize3Stride4Test(
9458 armnn::IWorkloadFactory& workloadFactory,
9459 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9461 return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9464 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
9465 armnn::IWorkloadFactory& workloadFactory,
9466 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9468 return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9471 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride4Int16Test(
9472 armnn::IWorkloadFactory& workloadFactory,
9473 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9475 return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9478 LayerTestResult<float, 4> L2Pooling2dSize7Test(
9479 armnn::IWorkloadFactory& workloadFactory,
9480 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9482 return L2Pooling2dSize7TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9485 LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
9486 armnn::IWorkloadFactory& workloadFactory,
9487 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9489 return L2Pooling2dSize7TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9492 LayerTestResult<int16_t, 4> L2Pooling2dSize7Int16Test(
9493 armnn::IWorkloadFactory& workloadFactory,
9494 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9496 return L2Pooling2dSize7TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9499 LayerTestResult<float, 4> L2Pooling2dSize9Test(
9500 armnn::IWorkloadFactory& workloadFactory,
9501 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9503 return L2Pooling2dSize9TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9506 LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
9507 armnn::IWorkloadFactory& workloadFactory,
9508 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9510 return L2Pooling2dSize9TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9513 LayerTestResult<int16_t, 4> L2Pooling2dSize9Int16Test(
9514 armnn::IWorkloadFactory& workloadFactory,
9515 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9517 return L2Pooling2dSize9TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9519 LayerTestResult<float, 4> IgnorePaddingSimpleL2Pooling2dTest(
9520 armnn::IWorkloadFactory& workloadFactory,
9521 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9523 return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9526 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
9527 armnn::IWorkloadFactory& workloadFactory,
9528 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9530 return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9533 LayerTestResult<int16_t, 4> IgnorePaddingSimpleL2Pooling2dInt16Test(
9534 armnn::IWorkloadFactory& workloadFactory,
9535 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9537 return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9540 LayerTestResult<float, 4> IgnorePaddingL2Pooling2dSize3Test(
9541 armnn::IWorkloadFactory& workloadFactory,
9542 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9544 return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9547 LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
9548 armnn::IWorkloadFactory& workloadFactory,
9549 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9551 return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9554 LayerTestResult<int16_t, 4> IgnorePaddingL2Pooling2dSize3Int16Test(
9555 armnn::IWorkloadFactory& workloadFactory,
9556 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9558 return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9561 LayerTestResult<float, 4> AsymmetricNonSquarePooling2dTest(
9562 armnn::IWorkloadFactory& workloadFactory,
9563 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9565 return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager);
9568 LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
9569 armnn::IWorkloadFactory& workloadFactory,
9570 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9572 return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9575 LayerTestResult<int16_t, 4> AsymmetricNonSquarePooling2dInt16Test(
9576 armnn::IWorkloadFactory& workloadFactory,
9577 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9579 return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9582 LayerTestResult<float, 4> ComparePooling2dTest(
9583 armnn::IWorkloadFactory& workloadFactory,
9584 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9585 armnn::IWorkloadFactory& refWorkloadFactory,
9586 armnn::PoolingAlgorithm poolingType)
9588 return ComparePooling2dTestCommon<armnn::DataType::Float32>(
9589 workloadFactory, memoryManager, refWorkloadFactory, poolingType);
9592 LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
9593 armnn::IWorkloadFactory& workloadFactory,
9594 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9595 armnn::IWorkloadFactory& refWorkloadFactory,
9596 armnn::PoolingAlgorithm poolingType)
9598 return ComparePooling2dTestCommon<armnn::DataType::QuantisedAsymm8>(
9599 workloadFactory, memoryManager, refWorkloadFactory, poolingType, 0.1f, 128);
9602 LayerTestResult<int16_t, 4> ComparePooling2dInt16Test(
9603 armnn::IWorkloadFactory& workloadFactory,
9604 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9605 armnn::IWorkloadFactory& refWorkloadFactory,
9606 armnn::PoolingAlgorithm poolingType)
9608 return ComparePooling2dTestCommon<armnn::DataType::QuantisedSymm16>(
9609 workloadFactory, memoryManager, refWorkloadFactory, poolingType);
9612 LayerTestResult<float, 2> FullyConnectedLargeTest(
9613 armnn::IWorkloadFactory& workloadFactory,
9614 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
9615 bool transposeWeights)
9617 return FullyConnectedLargeTestCommon<armnn::DataType::Float32>(workloadFactory, memoryManager, transposeWeights);
9620 LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
9621 armnn::IWorkloadFactory& workloadFactory,
9622 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9624 // Create Initial Tensor
9629 armnn::TensorInfo poolingInputTensorInfo({ 1, 1, 3, 3}, armnn::DataType::Float32);
9630 armnn::TensorInfo poolingOutputTensorInfo({ 1, 1, 2, 2}, armnn::DataType::Float32);
9632 boost::multi_array<float, 4> poolingInput = MakeTensor<float,4>(poolingInputTensorInfo,
9638 std::unique_ptr<armnn::ITensorHandle> poolingInputHandle =
9639 workloadFactory.CreateTensorHandle(poolingInputTensorInfo);
9640 std::unique_ptr<armnn::ITensorHandle> poolingOutputHandle =
9641 workloadFactory.CreateTensorHandle(poolingOutputTensorInfo);
9643 // Apply MaxPool poolSize = 1x1, stride=2x2
9647 armnn::Pooling2dDescriptor descriptor;
9648 descriptor.m_PoolHeight = 1;
9649 descriptor.m_PoolWidth = 1;
9650 descriptor.m_StrideX = 2;
9651 descriptor.m_StrideY = 2;
9652 descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
9654 armnn::Pooling2dQueueDescriptor queueDescriptor;
9655 queueDescriptor.m_Parameters = descriptor;
9656 armnn::WorkloadInfo workloadInfo;
9657 AddInputToWorkload(queueDescriptor, workloadInfo, poolingInputTensorInfo, poolingInputHandle.get());
9658 AddOutputToWorkload(queueDescriptor, workloadInfo, poolingOutputTensorInfo, poolingOutputHandle.get());
9660 // Create the MaxPool
9661 std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePooling2d(queueDescriptor, workloadInfo);
9663 //LayerTestResult<float, 4> result(poolingOutputTensorInfo);
9664 auto shape( GetTensorShapeAsArray<4>(poolingOutputTensorInfo));
9665 boost::multi_array<float, 4> resultMaxPool;
9666 resultMaxPool.resize(shape);
9669 // Create addition with another tensor the same size
9670 // This would be the result to apply a Conv2d with kernel ones(2) and stride 1x1
9671 // with the initial tensor.
9675 armnn::TensorInfo addInputTensorInfo({ 1,1,2,2}, armnn::DataType::Float32);
9676 armnn::TensorInfo addOutputTensorInfo({ 1,1,2,2}, armnn::DataType::Float32);
9678 boost::multi_array<float, 4> addInput = MakeTensor<float,4>(addInputTensorInfo,
9683 // Expected output tensor after MaxPool and Addition.
9684 LayerTestResult<float,4> addRet(addOutputTensorInfo);
9685 addRet.outputExpected = MakeTensor<float, 4>(addOutputTensorInfo, std::vector<float>(
9691 std::unique_ptr<armnn::ITensorHandle> addInputHandle = workloadFactory.CreateTensorHandle(addInputTensorInfo);
9692 std::unique_ptr<armnn::ITensorHandle> addOutputHandle = workloadFactory.CreateTensorHandle(addOutputTensorInfo);
9694 armnn::AdditionQueueDescriptor data;
9695 armnn::WorkloadInfo info;
9697 // Add the output of the MaxPool and the new tensor
9698 AddInputToWorkload(data, info, poolingOutputTensorInfo, poolingOutputHandle.get());
9699 AddInputToWorkload(data, info, addInputTensorInfo, addInputHandle.get());
9700 AddOutputToWorkload(data, info, addOutputTensorInfo, addOutputHandle.get());
9702 std::unique_ptr<armnn::IWorkload> addWorkload = workloadFactory.CreateAddition(data, info);
9704 poolingInputHandle->Allocate();
9705 poolingOutputHandle->Allocate();
9706 addInputHandle->Allocate();
9707 addOutputHandle->Allocate();
9709 CopyDataToITensorHandle(poolingInputHandle.get(), &poolingInput[0][0][0][0]);
9710 CopyDataFromITensorHandle(&resultMaxPool[0][0][0][0], poolingOutputHandle.get());
9712 CopyDataToITensorHandle(poolingOutputHandle.get(), &resultMaxPool[0][0][0][0]);
9713 CopyDataToITensorHandle(addInputHandle.get(), &addInput[0][0][0][0]);
9715 workload->PostAllocationConfigure();
9716 workload->Execute();
9717 addWorkload->PostAllocationConfigure();
9718 addWorkload->Execute();
9720 CopyDataFromITensorHandle(&addRet.output[0][0][0][0], addOutputHandle.get());
9725 LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(
9726 armnn::IWorkloadFactory& workloadFactory,
9727 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9729 return SpaceToBatchNdSimpleTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9732 LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(
9733 armnn::IWorkloadFactory& workloadFactory,
9734 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9736 return SpaceToBatchNdMultiChannelsTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9739 LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(
9740 armnn::IWorkloadFactory& workloadFactory,
9741 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9743 return SpaceToBatchNdMultiBlockTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9746 LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(
9747 armnn::IWorkloadFactory& workloadFactory,
9748 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9750 return SpaceToBatchNdPaddingTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9753 LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(
9754 armnn::IWorkloadFactory& workloadFactory,
9755 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9757 return SpaceToBatchNdSimpleTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9760 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(
9761 armnn::IWorkloadFactory& workloadFactory,
9762 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9764 return SpaceToBatchNdMultiChannelsTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9767 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(
9768 armnn::IWorkloadFactory& workloadFactory,
9769 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9771 return SpaceToBatchNdMultiBlockTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9774 LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(
9775 armnn::IWorkloadFactory& workloadFactory,
9776 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9778 return SpaceToBatchNdPaddingTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9781 LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(
9782 armnn::IWorkloadFactory& workloadFactory,
9783 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9785 return SpaceToBatchNdSimpleNHWCTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9788 LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(
9789 armnn::IWorkloadFactory& workloadFactory,
9790 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9792 return SpaceToBatchNdMultiChannelsNHWCTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9795 LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(
9796 armnn::IWorkloadFactory& workloadFactory,
9797 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9799 return SpaceToBatchNdMultiBlockNHWCTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9802 LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(
9803 armnn::IWorkloadFactory& workloadFactory,
9804 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9806 return SpaceToBatchNdPaddingNHWCTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9809 LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(
9810 armnn::IWorkloadFactory& workloadFactory,
9811 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9813 return SpaceToBatchNdSimpleNHWCTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9816 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(
9817 armnn::IWorkloadFactory& workloadFactory,
9818 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9820 return SpaceToBatchNdMultiChannelsNHWCTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9823 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(
9824 armnn::IWorkloadFactory& workloadFactory,
9825 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9827 return SpaceToBatchNdMultiBlockNHWCTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9830 LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(
9831 armnn::IWorkloadFactory& workloadFactory,
9832 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9834 return SpaceToBatchNdPaddingNHWCTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
9837 LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleUint16Test(
9838 armnn::IWorkloadFactory& workloadFactory,
9839 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9841 return SpaceToBatchNdSimpleTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9844 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsUint16Test(
9845 armnn::IWorkloadFactory& workloadFactory,
9846 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9848 return SpaceToBatchNdMultiChannelsTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9851 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockUint16Test(
9852 armnn::IWorkloadFactory& workloadFactory,
9853 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9855 return SpaceToBatchNdMultiBlockTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9858 LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingUint16Test(
9859 armnn::IWorkloadFactory& workloadFactory,
9860 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9862 return SpaceToBatchNdPaddingTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9865 LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleNHWCUint16Test(
9866 armnn::IWorkloadFactory& workloadFactory,
9867 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9869 return SpaceToBatchNdSimpleNHWCTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9872 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsNHWCUint16Test(
9873 armnn::IWorkloadFactory& workloadFactory,
9874 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9876 return SpaceToBatchNdMultiChannelsNHWCTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9879 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockNHWCUint16Test(
9880 armnn::IWorkloadFactory& workloadFactory,
9881 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9883 return SpaceToBatchNdMultiBlockNHWCTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9886 LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingNHWCUint16Test(
9887 armnn::IWorkloadFactory& workloadFactory,
9888 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9890 return SpaceToBatchNdPaddingNHWCTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
9893 LayerTestResult<uint8_t, 4> SpaceToDepthNHWCAsymmQ8Test(
9894 armnn::IWorkloadFactory& workloadFactory,
9895 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9897 return SpaceToDepthSimpleTest1<armnn::DataType::QuantisedAsymm8>(
9902 LayerTestResult<uint8_t, 4> SpaceToDepthNCHWAsymmQ8Test(
9903 armnn::IWorkloadFactory& workloadFactory,
9904 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9906 return SpaceToDepthSimpleTest1<armnn::DataType::QuantisedAsymm8>(
9909 armnn::DataLayout::NCHW);
9912 LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test1(
9913 armnn::IWorkloadFactory& workloadFactory,
9914 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9916 return SpaceToDepthSimpleTest1<armnn::DataType::Float32>(
9921 LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test1(
9922 armnn::IWorkloadFactory& workloadFactory,
9923 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9925 return SpaceToDepthSimpleTest1<armnn::DataType::Float32>(
9928 armnn::DataLayout::NCHW);
9931 LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test2(
9932 armnn::IWorkloadFactory& workloadFactory,
9933 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9935 return SpaceToDepthSimpleTest2<armnn::DataType::Float32>(
9940 LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test2(
9941 armnn::IWorkloadFactory& workloadFactory,
9942 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9944 return SpaceToDepthSimpleTest2<armnn::DataType::Float32>(
9947 armnn::DataLayout::NCHW);
9950 LayerTestResult<int16_t, 4> SpaceToDepthNHWCQSymm16Test(
9951 armnn::IWorkloadFactory& workloadFactory,
9952 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9954 return SpaceToDepthSimpleTest2<armnn::DataType::QuantisedSymm16>(
9959 LayerTestResult<int16_t, 4> SpaceToDepthNCHWQSymm16Test(
9960 armnn::IWorkloadFactory& workloadFactory,
9961 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9963 return SpaceToDepthSimpleTest2<armnn::DataType::QuantisedSymm16>(
9966 armnn::DataLayout::NCHW);
9971 } // anonymous namespace
9973 LayerTestResult<float, 4> StridedSlice4DFloat32Test(
9974 armnn::IWorkloadFactory& workloadFactory,
9975 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9977 return StridedSlice4DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9980 LayerTestResult<float, 4> StridedSlice4DReverseFloat32Test(
9981 armnn::IWorkloadFactory& workloadFactory,
9982 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9984 return StridedSlice4DReverseTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9987 LayerTestResult<float, 4> StridedSliceSimpleStrideFloat32Test(
9988 armnn::IWorkloadFactory& workloadFactory,
9989 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9991 return StridedSliceSimpleStrideTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
9994 LayerTestResult<float, 4> StridedSliceSimpleRangeMaskFloat32Test(
9995 armnn::IWorkloadFactory& workloadFactory,
9996 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
9998 return StridedSliceSimpleRangeMaskTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10001 LayerTestResult<float, 2> StridedSliceShrinkAxisMaskFloat32Test(
10002 armnn::IWorkloadFactory& workloadFactory,
10003 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10005 return StridedSliceShrinkAxisMaskTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10008 LayerTestResult<float, 3> StridedSlice3DFloat32Test(
10009 armnn::IWorkloadFactory& workloadFactory,
10010 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10012 return StridedSlice3DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10015 LayerTestResult<float, 3> StridedSlice3DReverseFloat32Test(
10016 armnn::IWorkloadFactory& workloadFactory,
10017 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10019 return StridedSlice3DReverseTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10022 LayerTestResult<float, 2> StridedSlice2DFloat32Test(
10023 armnn::IWorkloadFactory& workloadFactory,
10024 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10026 return StridedSlice2DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10029 LayerTestResult<float, 2> StridedSlice2DReverseFloat32Test(
10030 armnn::IWorkloadFactory& workloadFactory,
10031 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10033 return StridedSlice2DReverseTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10036 LayerTestResult<uint8_t, 4> StridedSlice4DUint8Test(
10037 armnn::IWorkloadFactory& workloadFactory,
10038 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10040 return StridedSlice4DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10043 LayerTestResult<uint8_t, 4> StridedSlice4DReverseUint8Test(
10044 armnn::IWorkloadFactory& workloadFactory,
10045 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10047 return StridedSlice4DReverseTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10050 LayerTestResult<uint8_t, 4> StridedSliceSimpleStrideUint8Test(
10051 armnn::IWorkloadFactory& workloadFactory,
10052 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10054 return StridedSliceSimpleStrideTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10057 LayerTestResult<uint8_t, 4> StridedSliceSimpleRangeMaskUint8Test(
10058 armnn::IWorkloadFactory& workloadFactory,
10059 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10061 return StridedSliceSimpleRangeMaskTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10064 LayerTestResult<uint8_t, 2> StridedSliceShrinkAxisMaskUint8Test(
10065 armnn::IWorkloadFactory& workloadFactory,
10066 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10068 return StridedSliceShrinkAxisMaskTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10071 LayerTestResult<uint8_t, 3> StridedSlice3DUint8Test(
10072 armnn::IWorkloadFactory& workloadFactory,
10073 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10075 return StridedSlice3DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10078 LayerTestResult<uint8_t, 3> StridedSlice3DReverseUint8Test(
10079 armnn::IWorkloadFactory& workloadFactory,
10080 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10082 return StridedSlice3DReverseTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10085 LayerTestResult<uint8_t, 2> StridedSlice2DUint8Test(
10086 armnn::IWorkloadFactory& workloadFactory,
10087 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10089 return StridedSlice2DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10092 LayerTestResult<uint8_t, 2> StridedSlice2DReverseUint8Test(
10093 armnn::IWorkloadFactory& workloadFactory,
10094 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10096 return StridedSlice2DReverseTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10099 LayerTestResult<int16_t, 4> StridedSlice4DInt16Test(
10100 armnn::IWorkloadFactory& workloadFactory,
10101 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10103 return StridedSlice4DTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10106 LayerTestResult<int16_t, 4> StridedSlice4DReverseInt16Test(
10107 armnn::IWorkloadFactory& workloadFactory,
10108 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10110 return StridedSlice4DReverseTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10113 LayerTestResult<int16_t, 4> StridedSliceSimpleStrideInt16Test(
10114 armnn::IWorkloadFactory& workloadFactory,
10115 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10117 return StridedSliceSimpleStrideTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10120 LayerTestResult<int16_t, 4> StridedSliceSimpleRangeMaskInt16Test(
10121 armnn::IWorkloadFactory& workloadFactory,
10122 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10124 return StridedSliceSimpleRangeMaskTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10127 LayerTestResult<int16_t, 2> StridedSliceShrinkAxisMaskInt16Test(
10128 armnn::IWorkloadFactory& workloadFactory,
10129 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10131 return StridedSliceShrinkAxisMaskTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10134 LayerTestResult<int16_t, 3> StridedSlice3DInt16Test(
10135 armnn::IWorkloadFactory& workloadFactory,
10136 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10138 return StridedSlice3DTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10141 LayerTestResult<int16_t, 3> StridedSlice3DReverseInt16Test(
10142 armnn::IWorkloadFactory& workloadFactory,
10143 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10145 return StridedSlice3DReverseTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10148 LayerTestResult<int16_t, 2> StridedSlice2DInt16Test(
10149 armnn::IWorkloadFactory& workloadFactory,
10150 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10152 return StridedSlice2DTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10155 LayerTestResult<int16_t, 2> StridedSlice2DReverseInt16Test(
10156 armnn::IWorkloadFactory& workloadFactory,
10157 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10159 return StridedSlice2DReverseTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10162 LayerTestResult<float, 4> Debug4DFloat32Test(
10163 armnn::IWorkloadFactory& workloadFactory,
10164 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10166 return Debug4DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10169 LayerTestResult<float, 3> Debug3DFloat32Test(
10170 armnn::IWorkloadFactory& workloadFactory,
10171 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10173 return Debug3DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10176 LayerTestResult<float, 2> Debug2DFloat32Test(
10177 armnn::IWorkloadFactory& workloadFactory,
10178 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10180 return Debug2DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10183 LayerTestResult<float, 1> Debug1DFloat32Test(
10184 armnn::IWorkloadFactory& workloadFactory,
10185 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10187 return Debug1DTest<armnn::DataType::Float32>(workloadFactory, memoryManager);
10190 LayerTestResult<uint8_t, 4> Debug4DUint8Test(
10191 armnn::IWorkloadFactory& workloadFactory,
10192 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10194 return Debug4DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10197 LayerTestResult<uint8_t, 3> Debug3DUint8Test(
10198 armnn::IWorkloadFactory& workloadFactory,
10199 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10201 return Debug3DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10204 LayerTestResult<uint8_t, 2> Debug2DUint8Test(
10205 armnn::IWorkloadFactory& workloadFactory,
10206 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10208 return Debug2DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10211 LayerTestResult<uint8_t, 1> Debug1DUint8Test(
10212 armnn::IWorkloadFactory& workloadFactory,
10213 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10215 return Debug1DTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10218 LayerTestResult<float, 1> Gather1DParamsFloatTest(
10219 armnn::IWorkloadFactory& workloadFactory,
10220 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10222 return Gather1DParamsTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager);
10225 LayerTestResult<uint8_t, 1> Gather1DParamsUint8Test(
10226 armnn::IWorkloadFactory& workloadFactory,
10227 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10229 return Gather1DParamsTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10232 LayerTestResult<int16_t, 1> Gather1DParamsInt16Test(
10233 armnn::IWorkloadFactory& workloadFactory,
10234 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10236 return Gather1DParamsTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10239 LayerTestResult<float, 2> GatherMultiDimParamsFloatTest(
10240 armnn::IWorkloadFactory& workloadFactory,
10241 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10243 return GatherMultiDimParamsTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager);
10246 LayerTestResult<uint8_t, 2> GatherMultiDimParamsUint8Test(
10247 armnn::IWorkloadFactory& workloadFactory,
10248 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10250 return GatherMultiDimParamsTestImpl<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10253 LayerTestResult<int16_t, 2> GatherMultiDimParamsInt16Test(
10254 armnn::IWorkloadFactory& workloadFactory,
10255 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10257 return GatherMultiDimParamsTestImpl<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10260 LayerTestResult<float, 4> GatherMultiDimParamsMultiDimIndicesFloatTest(
10261 armnn::IWorkloadFactory& workloadFactory,
10262 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10264 return GatherMultiDimParamsMultiDimIndicesTestImpl<armnn::DataType::Float32>(workloadFactory, memoryManager);
10267 LayerTestResult<uint8_t, 4> GatherMultiDimParamsMultiDimIndicesUint8Test(
10268 armnn::IWorkloadFactory& workloadFactory,
10269 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10271 return GatherMultiDimParamsMultiDimIndicesTestImpl<armnn::DataType::QuantisedAsymm8>(
10272 workloadFactory, memoryManager);
10275 LayerTestResult<int16_t, 4> GatherMultiDimParamsMultiDimIndicesInt16Test(
10276 armnn::IWorkloadFactory& workloadFactory,
10277 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10279 return GatherMultiDimParamsMultiDimIndicesTestImpl<armnn::DataType::QuantisedSymm16>(
10280 workloadFactory, memoryManager);
10283 LayerTestResult<float, 4> DequantizeSimpleUint8Test(
10284 armnn::IWorkloadFactory& workloadFactory,
10285 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10287 return DequantizeSimpleTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10290 LayerTestResult<float, 4> DequantizeOffsetUint8Test(
10291 armnn::IWorkloadFactory& workloadFactory,
10292 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10294 return DequantizeOffsetTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10297 LayerTestResult<float, 4> DequantizeSimpleInt16Test(
10298 armnn::IWorkloadFactory& workloadFactory,
10299 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10301 return DequantizeSimpleTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10304 LayerTestResult<uint8_t, 4> QuantizeSimpleUint8Test(
10305 armnn::IWorkloadFactory& workloadFactory,
10306 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10308 return QuantizeSimpleTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10311 LayerTestResult<uint8_t, 4> QuantizeClampUint8Test(
10312 armnn::IWorkloadFactory& workloadFactory,
10313 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10315 return QuantizeClampTest<armnn::DataType::QuantisedAsymm8>(workloadFactory, memoryManager);
10318 LayerTestResult<int16_t, 4> QuantizeClampInt16Test(
10319 armnn::IWorkloadFactory& workloadFactory,
10320 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10322 return QuantizeClampTest<armnn::DataType::QuantisedSymm16>(workloadFactory, memoryManager);
10326 // TransposeConvolution2d
10330 LayerTestResult<float, 4> SimpleTransposeConvolution2dFloatNchwTest(
10331 armnn::IWorkloadFactory& workloadFactory,
10332 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10334 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10338 armnn::DataLayout::NCHW);
10341 LayerTestResult<float, 4> SimpleTransposeConvolution2dFloatNhwcTest(
10342 armnn::IWorkloadFactory& workloadFactory,
10343 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10345 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10349 armnn::DataLayout::NHWC);
10352 LayerTestResult<uint8_t, 4> SimpleTransposeConvolution2dUint8NchwTest(
10353 armnn::IWorkloadFactory& workloadFactory,
10354 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10356 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10360 armnn::DataLayout::NCHW);
10363 LayerTestResult<uint8_t, 4> SimpleTransposeConvolution2dUint8NhwcTest(
10364 armnn::IWorkloadFactory& workloadFactory,
10365 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10367 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10371 armnn::DataLayout::NHWC);
10374 LayerTestResult<int16_t, 4> SimpleTransposeConvolution2dInt16NchwTest(
10375 armnn::IWorkloadFactory& workloadFactory,
10376 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10378 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10382 armnn::DataLayout::NCHW);
10385 LayerTestResult<int16_t, 4> SimpleTransposeConvolution2dInt16NhwcTest(
10386 armnn::IWorkloadFactory& workloadFactory,
10387 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10389 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10393 armnn::DataLayout::NHWC);
10397 LayerTestResult<float, 4> UnbiasedSimpleTransposeConvolution2dFloatNchwTest(
10398 armnn::IWorkloadFactory& workloadFactory,
10399 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10401 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10405 armnn::DataLayout::NCHW);
10408 LayerTestResult<float, 4> UnbiasedSimpleTransposeConvolution2dFloatNhwcTest(
10409 armnn::IWorkloadFactory& workloadFactory,
10410 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10412 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10416 armnn::DataLayout::NHWC);
10419 LayerTestResult<uint8_t, 4> UnbiasedSimpleTransposeConvolution2dUint8NchwTest(
10420 armnn::IWorkloadFactory& workloadFactory,
10421 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10423 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10427 armnn::DataLayout::NCHW);
10430 LayerTestResult<uint8_t, 4> UnbiasedSimpleTransposeConvolution2dUint8NhwcTest(
10431 armnn::IWorkloadFactory& workloadFactory,
10432 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10434 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10438 armnn::DataLayout::NHWC);
10441 LayerTestResult<int16_t, 4> UnbiasedSimpleTransposeConvolution2dInt16NchwTest(
10442 armnn::IWorkloadFactory& workloadFactory,
10443 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10445 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10449 armnn::DataLayout::NCHW);
10452 LayerTestResult<int16_t, 4> UnbiasedSimpleTransposeConvolution2dInt16NhwcTest(
10453 armnn::IWorkloadFactory& workloadFactory,
10454 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10456 return SimpleTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10460 armnn::DataLayout::NHWC);
10464 LayerTestResult<float, 4> PaddedTransposeConvolution2dFloatNchwTest(
10465 armnn::IWorkloadFactory& workloadFactory,
10466 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10468 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10472 armnn::DataLayout::NCHW);
10475 LayerTestResult<float, 4> PaddedTransposeConvolution2dFloatNhwcTest(
10476 armnn::IWorkloadFactory& workloadFactory,
10477 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10479 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10483 armnn::DataLayout::NHWC);
10486 LayerTestResult<uint8_t, 4> PaddedTransposeConvolution2dUint8NchwTest(
10487 armnn::IWorkloadFactory& workloadFactory,
10488 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10490 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10494 armnn::DataLayout::NCHW);
10497 LayerTestResult<uint8_t, 4> PaddedTransposeConvolution2dUint8NhwcTest(
10498 armnn::IWorkloadFactory& workloadFactory,
10499 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10501 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10505 armnn::DataLayout::NHWC);
10508 LayerTestResult<int16_t, 4> PaddedTransposeConvolution2dInt16NchwTest(
10509 armnn::IWorkloadFactory& workloadFactory,
10510 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10512 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10516 armnn::DataLayout::NCHW);
10519 LayerTestResult<int16_t, 4> PaddedTransposeConvolution2dInt16NhwcTest(
10520 armnn::IWorkloadFactory& workloadFactory,
10521 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10523 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10527 armnn::DataLayout::NHWC);
10531 LayerTestResult<float, 4> UnbiasedPaddedTransposeConvolution2dFloatNchwTest(
10532 armnn::IWorkloadFactory& workloadFactory,
10533 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10535 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10539 armnn::DataLayout::NCHW);
10542 LayerTestResult<float, 4> UnbiasedPaddedTransposeConvolution2dFloatNhwcTest(
10543 armnn::IWorkloadFactory& workloadFactory,
10544 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10546 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10550 armnn::DataLayout::NHWC);
10553 LayerTestResult<uint8_t, 4> UnbiasedPaddedTransposeConvolution2dUint8NchwTest(
10554 armnn::IWorkloadFactory& workloadFactory,
10555 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10557 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10561 armnn::DataLayout::NCHW);
10564 LayerTestResult<uint8_t, 4> UnbiasedPaddedTransposeConvolution2dUint8NhwcTest(
10565 armnn::IWorkloadFactory& workloadFactory,
10566 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10568 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10572 armnn::DataLayout::NHWC);
10575 LayerTestResult<int16_t, 4> UnbiasedPaddedTransposeConvolution2dInt16NchwTest(
10576 armnn::IWorkloadFactory& workloadFactory,
10577 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10579 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10583 armnn::DataLayout::NCHW);
10586 LayerTestResult<int16_t, 4> UnbiasedPaddedTransposeConvolution2dInt16NhwcTest(
10587 armnn::IWorkloadFactory& workloadFactory,
10588 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10590 return PaddedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10594 armnn::DataLayout::NHWC);
10598 LayerTestResult<float, 4> StridedTransposeConvolution2dFloatNchwTest(
10599 armnn::IWorkloadFactory& workloadFactory,
10600 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10602 return StridedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10606 armnn::DataLayout::NCHW);
10609 LayerTestResult<float, 4> StridedTransposeConvolution2dFloatNhwcTest(
10610 armnn::IWorkloadFactory& workloadFactory,
10611 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10613 return StridedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10617 armnn::DataLayout::NHWC);
10620 LayerTestResult<uint8_t, 4> StridedTransposeConvolution2dUint8NchwTest(
10621 armnn::IWorkloadFactory& workloadFactory,
10622 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10624 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10628 armnn::DataLayout::NCHW);
10631 LayerTestResult<uint8_t, 4> StridedTransposeConvolution2dUint8NhwcTest(
10632 armnn::IWorkloadFactory& workloadFactory,
10633 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10635 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10639 armnn::DataLayout::NHWC);
10642 LayerTestResult<int16_t, 4> StridedTransposeConvolution2dInt16NchwTest(
10643 armnn::IWorkloadFactory& workloadFactory,
10644 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10646 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10650 armnn::DataLayout::NCHW);
10653 LayerTestResult<int16_t, 4> StridedTransposeConvolution2dInt16NhwcTest(
10654 armnn::IWorkloadFactory& workloadFactory,
10655 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10657 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10661 armnn::DataLayout::NHWC);
10664 // Strided unbiased
10665 LayerTestResult<float, 4> UnbiasedStridedTransposeConvolution2dFloatNchwTest(
10666 armnn::IWorkloadFactory& workloadFactory,
10667 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10669 return StridedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10673 armnn::DataLayout::NCHW);
10676 LayerTestResult<float, 4> UnbiasedStridedTransposeConvolution2dFloatNhwcTest(
10677 armnn::IWorkloadFactory& workloadFactory,
10678 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10680 return StridedTransposeConvolution2dTestImpl<armnn::DataType::Float32, armnn::DataType::Float32>(
10684 armnn::DataLayout::NHWC);
10687 LayerTestResult<uint8_t, 4> UnbiasedStridedTransposeConvolution2dUint8NchwTest(
10688 armnn::IWorkloadFactory& workloadFactory,
10689 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10691 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10695 armnn::DataLayout::NCHW);
10698 LayerTestResult<uint8_t, 4> UnbiasedStridedTransposeConvolution2dUint8NhwcTest(
10699 armnn::IWorkloadFactory& workloadFactory,
10700 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10702 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
10706 armnn::DataLayout::NHWC);
10709 LayerTestResult<int16_t, 4> UnbiasedStridedTransposeConvolution2dInt16NchwTest(
10710 armnn::IWorkloadFactory& workloadFactory,
10711 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10713 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10717 armnn::DataLayout::NCHW);
10720 LayerTestResult<int16_t, 4> UnbiasedStridedTransposeConvolution2dInt16NhwcTest(
10721 armnn::IWorkloadFactory& workloadFactory,
10722 const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
10724 return StridedTransposeConvolution2dTestImpl<armnn::DataType::QuantisedSymm16, armnn::DataType::Signed32>(
10728 armnn::DataLayout::NHWC);