From de7055840ad27de2f60e80bf6e264705db4c0d19 Mon Sep 17 00:00:00 2001 From: =?utf8?q?=C3=89anna=20=C3=93=20Cath=C3=A1in?= Date: Mon, 3 Dec 2018 13:04:22 +0000 Subject: [PATCH] IVGCVSW-2255 Add unit test for maximum reference workload * Enable Maximum workload Change-Id: I5f7786ff66f135f0c74935dbf5861e5a4239bcc8 --- src/backends/backendsCommon/StringMapping.hpp | 1 + src/backends/backendsCommon/test/LayerTests.cpp | 244 ++++++++++++++++++++++++ src/backends/backendsCommon/test/LayerTests.hpp | 24 +++ src/backends/reference/test/RefLayerTests.cpp | 8 + 4 files changed, 277 insertions(+) diff --git a/src/backends/backendsCommon/StringMapping.hpp b/src/backends/backendsCommon/StringMapping.hpp index f6af821..8fca3d3 100644 --- a/src/backends/backendsCommon/StringMapping.hpp +++ b/src/backends/backendsCommon/StringMapping.hpp @@ -37,6 +37,7 @@ private: { m_Strings[RefAdditionWorkload_Execute] = "RefAdditionWorkload_Execute"; m_Strings[RefSubtractionWorkload_Execute] = "RefSubtractionWorkload_Execute"; + m_Strings[RefMaximumWorkload_Execute] = "RefMaximumWorkload_Execute"; m_Strings[RefMultiplicationWorkload_Execute] = "RefMultiplicationWorkload_Execute"; m_Strings[RefDivisionWorkload_Execute] = "RefDivisionWorkload_Execute"; } diff --git a/src/backends/backendsCommon/test/LayerTests.cpp b/src/backends/backendsCommon/test/LayerTests.cpp index 8cb4e09..c3822bd 100755 --- a/src/backends/backendsCommon/test/LayerTests.cpp +++ b/src/backends/backendsCommon/test/LayerTests.cpp @@ -19,6 +19,8 @@ #include #include +#include + #include #include @@ -1635,6 +1637,248 @@ LayerTestResult DivisionBroadcast1DVectorUint8Test( shape0, output, 1.0f, 0); } +template +std::unique_ptr CreateWorkload( + const armnn::IWorkloadFactory& workloadFactory, + const armnn::WorkloadInfo& info, + const DescriptorType& descriptor) +{ + return CreateWorkload(workloadFactory, info, descriptor); +}; + +template<> +std::unique_ptr CreateWorkload( + const armnn::IWorkloadFactory& workloadFactory, + const armnn::WorkloadInfo& info, + const armnn::MaximumQueueDescriptor& descriptor) +{ + return workloadFactory.CreateMaximum(descriptor, info); +} + +namespace { + template + LayerTestResult ElementwiseTestHelper + (armnn::IWorkloadFactory & workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager, + const unsigned int shape0[4], std::vector values0, + const unsigned int shape1[4], std::vector values1, + const unsigned int outShape[4], std::vector outValues, + float qScale = 0.0f, int qOffset = 0) + { + const size_t dimensionCount = 4; + armnn::TensorInfo inputTensorInfo0{dimensionCount, shape0, armnn::GetDataType()}; + armnn::TensorInfo inputTensorInfo1{dimensionCount, shape1, armnn::GetDataType()}; + armnn::TensorInfo outputTensorInfo{dimensionCount, outShape, armnn::GetDataType()}; + + auto input0 = MakeTensor(inputTensorInfo0, values0); + auto input1 = MakeTensor(inputTensorInfo1, values1); + + if (armnn::IsQuantizedType()) + { + inputTensorInfo0.SetQuantizationScale(qScale); + inputTensorInfo0.SetQuantizationOffset(qOffset); + + inputTensorInfo1.SetQuantizationScale(qScale); + inputTensorInfo1.SetQuantizationOffset(qOffset); + + outputTensorInfo.SetQuantizationScale(qScale); + outputTensorInfo.SetQuantizationOffset(qOffset); + } + + LayerTestResult ret(outputTensorInfo); + + std::unique_ptr inputHandle0 = workloadFactory.CreateTensorHandle(inputTensorInfo0); + std::unique_ptr inputHandle1 = workloadFactory.CreateTensorHandle(inputTensorInfo1); + std::unique_ptr outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo); + + Descriptor data; + armnn::WorkloadInfo info; + AddInputToWorkload(data, info, inputTensorInfo0, inputHandle0.get()); + AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get()); + AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); + auto workload = CreateWorkload(workloadFactory, info, data); + + inputHandle0->Allocate(); + inputHandle1->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle0.get(), &input0[0][0][0][0]); + CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0][0]); + + ExecuteWorkload(*workload, memoryManager); + + CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get()); + + ret.outputExpected = MakeTensor(outputTensorInfo, outValues); + return ret; + } +} + + +LayerTestResult MaximumSimpleTest(armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int width = 2; + const unsigned int height = 2; + const unsigned int channelCount = 2; + const unsigned int batchSize = 2; + + unsigned int shape[] = { batchSize, channelCount, height, width }; + + std::vector input0({ 1, 1, 1, 1, 5, 5, 5, 5, + 3, 3, 3, 3, 4, 4, 4, 4 }); + + std::vector input1({ 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5 }); + + std::vector output({ 2, 2, 2, 2, 5, 5, 5, 5, + 4, 4, 4, 4, 5, 5, 5, 5 }); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape, + input0, + shape, + input1, + shape, + output); +} + +LayerTestResult MaximumBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + unsigned int shape0[] = { 1, 2, 2, 2 }; + std::vector input0({ 1, 2, 3, 4, 5, 6, 7, 8}); + + unsigned int shape1[] = { 1, 1, 1, 1 }; + std::vector input1({ 2 }); + + std::vector output({ 2, 2, 3, 4, 5, 6, 7, 8}); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape0, + input0, + shape1, + input1, + shape0, + output); +} + +LayerTestResult MaximumBroadcast1DVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int shape0[] = { 1, 2, 2, 3 }; + const unsigned int shape1[] = { 1, 1, 1, 3 }; + + std::vector input0({ 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 }); + + std::vector input1({ 1, 2, 3}); + + std::vector output({ 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 }); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape0, + input0, + shape1, + input1, + shape0, + output); +} + +LayerTestResult MaximumUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + unsigned int shape[] = { 2, 2, 2, 2 }; + + // See dequantized values to the right. + std::vector input0({ 1, 1, 1, 1, 6, 6, 6, 6, + 3, 3, 3, 3, 4, 4, 4, 4 }); + + std::vector input1({ 2, 2, 2, 2, 3, 3, 3, 3, + 4, 4, 4, 4, 5, 5, 5, 5 }); + + std::vector output({ 2, 2, 2, 2, 6, 6, 6, 6, + 4, 4, 4, 4, 5, 5, 5, 5 }); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape, + input0, + shape, + input1, + shape, + output, + 1.0f, + 0); +} + +LayerTestResult MaximumBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int shape0[] = { 1, 2, 2, 3 }; + const unsigned int shape1[] = { 1, 1, 1, 1 }; + + std::vector input0({ 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 }); + + std::vector input1({2}); + + std::vector output({ 2, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 }); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape0, + input0, + shape1, + input1, + shape0, + output, + 1.0f, + 0); +} + +LayerTestResult MaximumBroadcast1DVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager) +{ + const unsigned int shape0[] = { 1, 2, 2, 3 }; + const unsigned int shape1[] = { 1, 1, 1, 3 }; + + std::vector input0({ 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12 }); + + std::vector input1({ 1, 10, 3}); + + std::vector output({ 1, 10, 3, 4, 10, 6, + 7, 10, 9, 10, 11, 12 }); + + return ElementwiseTestHelper + (workloadFactory, + memoryManager, + shape0, + input0, + shape1, + input1, + shape0, + output, + 1.0f, + 0); +} + namespace { LayerTestResult MultiplicationTestHelper( armnn::IWorkloadFactory& workloadFactory, diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index bfb9e04..fa1c864 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -936,6 +936,30 @@ LayerTestResult SimpleConvertFp32ToFp16Test( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); +LayerTestResult MaximumSimpleTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult MaximumBroadcast1ElementTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult MaximumBroadcast1DVectorTest( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult MaximumUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult MaximumBroadcast1ElementUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + +LayerTestResult MaximumBroadcast1DVectorUint8Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); + LayerTestResult MeanUint8SimpleTest( armnn::IWorkloadFactory& workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager); diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index df52d1d..54ec697 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -233,6 +233,14 @@ ARMNN_AUTO_TEST_CASE(DivisionUint8, DivisionUint8Test) ARMNN_AUTO_TEST_CASE(DivisionUint8Broadcast1Element, DivisionBroadcast1ElementUint8Test) ARMNN_AUTO_TEST_CASE(DivisionUint8Broadcast1DVector, DivisionBroadcast1DVectorUint8Test) +//Max +ARMNN_AUTO_TEST_CASE(SimpleMaximum, MaximumSimpleTest) +ARMNN_AUTO_TEST_CASE(MaximumBroadcast1Element, MaximumBroadcast1ElementTest) +ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVector, MaximumBroadcast1DVectorTest) +ARMNN_AUTO_TEST_CASE(MaximumUint8, MaximumUint8Test) +ARMNN_AUTO_TEST_CASE(MaximumBroadcast1ElementUint8, MaximumBroadcast1ElementUint8Test) +ARMNN_AUTO_TEST_CASE(MaximumBroadcast1DVectorUint8, MaximumBroadcast1DVectorUint8Test) + // Mul ARMNN_AUTO_TEST_CASE(SimpleMultiplication, MultiplicationTest) ARMNN_AUTO_TEST_CASE(MultiplicationBroadcast1Element, MultiplicationBroadcast1ElementTest) -- 2.7.4