From 581742d8b6c25bf0917d6bdcd5f9b8a5e72b370d Mon Sep 17 00:00:00 2001 From: Sadik Armagan Date: Mon, 12 Aug 2019 14:11:37 +0100 Subject: IVGCVSW-3163 Support Neon TransposeConv2d * NEON support for TransposeConolution2d * Indentation fix on SpaceToDepth LayerSupport method Signed-off-by: Keith Davis Signed-off-by: Sadik Armagan Signed-off-by: Aron Virginas-Tar Change-Id: Ie3a01a22e05f62f475f768dfe05ce561d2f3b0ad --- src/armnn/LayerSupport.cpp | 10 +- src/backends/neon/NeonLayerSupport.cpp | 17 + src/backends/neon/NeonLayerSupport.hpp | 8 + src/backends/neon/NeonWorkloadFactory.cpp | 8 + src/backends/neon/NeonWorkloadFactory.hpp | 3 + src/backends/neon/backend.mk | 3 +- src/backends/neon/test/NeonEndToEndTests.cpp | 25 + src/backends/neon/test/NeonLayerTests.cpp | 549 ++++++++++++--------- src/backends/neon/workloads/CMakeLists.txt | 2 + .../NeonTransposeConvolution2dWorkload.cpp | 109 ++++ .../NeonTransposeConvolution2dWorkload.hpp | 45 ++ src/backends/neon/workloads/NeonWorkloads.hpp | 1 + 12 files changed, 553 insertions(+), 227 deletions(-) create mode 100644 src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp create mode 100644 src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.hpp diff --git a/src/armnn/LayerSupport.cpp b/src/armnn/LayerSupport.cpp index 5a756b9544..d730205981 100644 --- a/src/armnn/LayerSupport.cpp +++ b/src/armnn/LayerSupport.cpp @@ -574,11 +574,11 @@ bool IsSpaceToBatchNdSupported(const BackendId& backend, } bool IsSpaceToDepthSupported(const BackendId& backend, - const TensorInfo& input, - const TensorInfo& output, - const SpaceToDepthDescriptor& descriptor, - char* reasonIfUnsupported, - size_t reasonIfUnsupportedMaxLength) + const TensorInfo& input, + const TensorInfo& output, + const SpaceToDepthDescriptor& descriptor, + char* reasonIfUnsupported, + size_t reasonIfUnsupportedMaxLength) { FORWARD_LAYER_SUPPORT_FUNC(backend, IsSpaceToDepthSupported, input, output, descriptor); } diff --git a/src/backends/neon/NeonLayerSupport.cpp b/src/backends/neon/NeonLayerSupport.cpp index 26abc16c46..80695fb3c7 100644 --- a/src/backends/neon/NeonLayerSupport.cpp +++ b/src/backends/neon/NeonLayerSupport.cpp @@ -47,6 +47,7 @@ #include "workloads/NeonStackWorkload.hpp" #include "workloads/NeonStridedSliceWorkload.hpp" #include "workloads/NeonSubtractionWorkload.hpp" +#include "workloads/NeonTransposeConvolution2dWorkload.hpp" #endif using namespace boost; @@ -634,4 +635,20 @@ bool NeonLayerSupport::IsSubtractionSupported(const TensorInfo& input0, output); } +bool NeonLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input, + const TensorInfo& output, + const TransposeConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional& biases, + Optional reasonIfUnsupported) const +{ + FORWARD_WORKLOAD_VALIDATE_FUNC(NeonTransposeConvolution2dWorkloadValidate, + reasonIfUnsupported, + input, + output, + descriptor, + weights, + biases); +} + } // namespace armnn diff --git a/src/backends/neon/NeonLayerSupport.hpp b/src/backends/neon/NeonLayerSupport.hpp index 744683f77a..7ba90e4c93 100644 --- a/src/backends/neon/NeonLayerSupport.hpp +++ b/src/backends/neon/NeonLayerSupport.hpp @@ -221,6 +221,14 @@ public: const TensorInfo& input1, const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; + + bool IsTransposeConvolution2dSupported(const TensorInfo& input, + const TensorInfo& output, + const TransposeConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional& biases, + Optional reasonIfUnsupported = EmptyOptional()) const override; + }; // class NeonLayerSupport } // namespace armnn diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp index 36b176626d..a22a64fe91 100644 --- a/src/backends/neon/NeonWorkloadFactory.cpp +++ b/src/backends/neon/NeonWorkloadFactory.cpp @@ -398,6 +398,14 @@ std::unique_ptr NeonWorkloadFactory::CreateRsqrt(const RsqrtQueueDesc return MakeWorkloadHelper(descriptor, info); } +std::unique_ptr NeonWorkloadFactory::CreateTransposeConvolution2d( + const TransposeConvolution2dQueueDescriptor &descriptor, + const WorkloadInfo &info) const +{ + return std::make_unique(descriptor, info, + m_MemoryManager->GetIntraLayerManager()); +} + std::unique_ptr NeonWorkloadFactory::CreatePreCompiled(const PreCompiledQueueDescriptor& descriptor, const WorkloadInfo& info) const { diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp index b9995d8b4b..de0bd5c2e0 100644 --- a/src/backends/neon/NeonWorkloadFactory.hpp +++ b/src/backends/neon/NeonWorkloadFactory.hpp @@ -177,6 +177,9 @@ public: std::unique_ptr CreateDebug(const DebugQueueDescriptor& descriptor, const WorkloadInfo& info) const override; + std::unique_ptr CreateTransposeConvolution2d(const TransposeConvolution2dQueueDescriptor& descriptor, + const WorkloadInfo& info) const override; + std::unique_ptr CreateRsqrt(const RsqrtQueueDescriptor& descriptor, const WorkloadInfo& info) const override; diff --git a/src/backends/neon/backend.mk b/src/backends/neon/backend.mk index 4a0d05ecdd..9ceb843868 100644 --- a/src/backends/neon/backend.mk +++ b/src/backends/neon/backend.mk @@ -55,7 +55,8 @@ BACKEND_SOURCES := \ workloads/NeonSplitterWorkload.cpp \ workloads/NeonStackWorkload.cpp \ workloads/NeonStridedSliceWorkload.cpp \ - workloads/NeonSubtractionWorkload.cpp + workloads/NeonSubtractionWorkload.cpp \ + workloads/NeonTransposeConvolution2dWorkload.cpp else diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp index 81e5d80cbe..9f94151c1d 100644 --- a/src/backends/neon/test/NeonEndToEndTests.cpp +++ b/src/backends/neon/test/NeonEndToEndTests.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include @@ -273,4 +274,28 @@ BOOST_AUTO_TEST_CASE(NeonQuantizedLstmEndToEndTest) QuantizedLstmEndToEnd(defaultBackends); } +BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndFloatNchwTest) +{ + TransposeConvolution2dEndToEnd( + defaultBackends, armnn::DataLayout::NCHW); +} + +BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndUint8NchwTest) +{ + TransposeConvolution2dEndToEnd( + defaultBackends, armnn::DataLayout::NCHW); +} + +BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndFloatNhwcTest) +{ + TransposeConvolution2dEndToEnd( + defaultBackends, armnn::DataLayout::NHWC); +} + +BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndUint8NhwcTest) +{ + TransposeConvolution2dEndToEnd( + defaultBackends, armnn::DataLayout::NHWC); +} + BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp index e8f69d2ef2..a701362c7f 100644 --- a/src/backends/neon/test/NeonLayerTests.cpp +++ b/src/backends/neon/test/NeonLayerTests.cpp @@ -16,12 +16,16 @@ #include #include #include +#include #include #include BOOST_AUTO_TEST_SUITE(Compute_ArmComputeNeon) -using FactoryType = armnn::NeonWorkloadFactory; + +using namespace armnn; + +using FactoryType = NeonWorkloadFactory; // ============================================================================ // UNIT tests @@ -29,97 +33,97 @@ using FactoryType = armnn::NeonWorkloadFactory; // Convolution ARMNN_AUTO_TEST_CASE(SimpleConvolution1d, Convolution1dTest, true) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d, SimpleConvolution2d3x5Test, true, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dNhwc, SimpleConvolution2d3x5Test, true, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8, SimpleConvolution2d3x3Uint8Test, true, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8Nhwc, SimpleConvolution2d3x3Uint8Test, true, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2d, SimpleConvolution2d3x5Test, false, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dNhwc, SimpleConvolution2d3x5Test, false, armnn::DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleConvolution2d, SimpleConvolution2d3x5Test, true, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleConvolution2dNhwc, SimpleConvolution2d3x5Test, true, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleConvolution2d3x3Uint8Nhwc, SimpleConvolution2d3x3Uint8Test, true, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2d, SimpleConvolution2d3x5Test, false, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dNhwc, SimpleConvolution2d3x5Test, false, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dStride2x2Nhwc, - SimpleConvolution2d3x3Stride2x2Test, false, armnn::DataLayout::NHWC) + SimpleConvolution2d3x3Stride2x2Test, false, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquare, SimpleConvolution2d3x3Test, false, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPadding, Convolution2dAsymmetricPaddingTest, armnn::DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquare, SimpleConvolution2d3x3Test, false, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPadding, Convolution2dAsymmetricPaddingTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquareNhwc, SimpleConvolution2d3x3Test, false, armnn::DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UnbiasedConvolution2dSquareNhwc, SimpleConvolution2d3x3Test, false, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleConvolution2dAsymmetricPaddingNhwc, Convolution2dAsymmetricPaddingTest, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleConvolution2dSquareNhwc, SimpleConvolution2d3x3NhwcTest, false) ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3, - Convolution2d3x3Dilation3x3Test, + Convolution2d3x3Dilation3x3Test, false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3Nhwc, - Convolution2d3x3Dilation3x3Test, + Convolution2d3x3Dilation3x3Test, false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3Uint8, - Convolution2d3x3Dilation3x3Test, + Convolution2d3x3Dilation3x3Test, false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d3x3Dilation3x3NhwcUint8, - Convolution2d3x3Dilation3x3Test, + Convolution2d3x3Dilation3x3Test, false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3, - Convolution2d2x3x3Dilation3x3Test, + Convolution2d2x3x3Dilation3x3Test, false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3Nhwc, - Convolution2d2x3x3Dilation3x3Test, + Convolution2d2x3x3Dilation3x3Test, false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3Uint8, - Convolution2d2x3x3Dilation3x3Test, + Convolution2d2x3x3Dilation3x3Test, false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d2x3x3Dilation3x3NhwcUint8, - Convolution2d2x3x3Dilation3x3Test, + Convolution2d2x3x3Dilation3x3Test, false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3, Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test - , + , false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Nhwc, Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test - , + , false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3Uint8, Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test - , + , false, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(Convolution2d2x2Dilation2x2Padding2x2Stride3x3NhwcUint8, Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test - , + , false, - armnn::DataLayout::NHWC) + DataLayout::NHWC) // Depthwise Convolution ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, true, armnn::DataLayout::NCHW) + DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1, - DepthwiseConvolution2dDepthMul1Test, false, armnn::DataLayout::NCHW) + DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, true, armnn::DataLayout::NCHW) + DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Uint8, - DepthwiseConvolution2dDepthMul1Uint8Test, false, armnn::DataLayout::NCHW) + DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NCHW) // NHWC Depthwise Convolution ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1NHhwc, - DepthwiseConvolution2dDepthMul1Test, true, armnn::DataLayout::NHWC) + DepthwiseConvolution2dDepthMul1Test, true, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Nhwc, - DepthwiseConvolution2dDepthMul1Test, false, armnn::DataLayout::NHWC) + DepthwiseConvolution2dDepthMul1Test, false, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, true, armnn::DataLayout::NHWC) + DepthwiseConvolution2dDepthMul1Uint8Test, true, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dDepthMul1Uint8Nhwc, - DepthwiseConvolution2dDepthMul1Uint8Test, false, armnn::DataLayout::NHWC) + DepthwiseConvolution2dDepthMul1Uint8Test, false, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthNhwc, DepthwiseConvolution2dDepthNhwcTest, false) ARMNN_AUTO_TEST_CASE(SimpleDepthwiseConvolution2d3x3Dilation3x3Nhwc, @@ -127,26 +131,26 @@ ARMNN_AUTO_TEST_CASE(SimpleDepthwiseConvolution2d3x3Dilation3x3Nhwc, ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, true, armnn::DataLayout::NCHW) + DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dAsymmetric, - DepthwiseConvolution2dAsymmetricTest, false, armnn::DataLayout::NCHW) + DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, true, armnn::DataLayout::NHWC) + DepthwiseConvolution2dAsymmetricTest, true, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(UnbiasedDepthwiseConvolution2dAsymmetricNhwc, - DepthwiseConvolution2dAsymmetricTest, false, armnn::DataLayout::NHWC) + DepthwiseConvolution2dAsymmetricTest, false, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(DepthwiseConvolution2dDepthMul64, DepthwiseConvolution2dDepthMul64Test); namespace { -armnn::DepthwiseConvolution2dDescriptor MakeDepthwiseConv2dDesc(uint32_t strideX, uint32_t strideY, +DepthwiseConvolution2dDescriptor MakeDepthwiseConv2dDesc(uint32_t strideX, uint32_t strideY, uint32_t depthMultiplier = 1, uint32_t padLeft = 0, uint32_t padRight = 0, uint32_t padTop = 0, uint32_t padBottom = 0) { boost::ignore_unused(depthMultiplier); - armnn::DepthwiseConvolution2dDescriptor desc; + DepthwiseConvolution2dDescriptor desc; desc.m_PadLeft = padLeft; desc.m_PadRight = padRight; @@ -160,13 +164,13 @@ armnn::DepthwiseConvolution2dDescriptor MakeDepthwiseConv2dDesc(uint32_t strideX return desc; } -armnn::TensorInfo CreateOutputTensorInfo(const armnn::TensorInfo& inputInfo, - const armnn::TensorInfo& weightsInfo, - const armnn::DepthwiseConvolution2dDescriptor& descriptor, - armnn::DataType dataType) +TensorInfo CreateOutputTensorInfo(const TensorInfo& inputInfo, + const TensorInfo& weightsInfo, + const DepthwiseConvolution2dDescriptor& descriptor, + DataType dataType) { - const armnn::TensorShape& inputShape = inputInfo.GetShape(); - const armnn::TensorShape& filterShape = weightsInfo.GetShape(); + const TensorShape& inputShape = inputInfo.GetShape(); + const TensorShape& filterShape = weightsInfo.GetShape(); unsigned int inWidth = inputShape[3]; unsigned int inHeight = inputShape[2]; @@ -184,22 +188,22 @@ armnn::TensorInfo CreateOutputTensorInfo(const armnn::TensorInfo& inputInfo, unsigned int outChannels = filterShape[1] * depthMultiplier; unsigned int outBatchSize = inBatchSize; - armnn::TensorShape outputShape({outBatchSize, outChannels, outHeight, outWidth}); - return armnn::TensorInfo(outputShape, dataType); + TensorShape outputShape({outBatchSize, outChannels, outHeight, outWidth}); + return TensorInfo(outputShape, dataType); } } BOOST_AUTO_TEST_CASE(DepthwiseConv2dUtils) { - const armnn::DataType dataType = armnn::DataType::Float32; + const DataType dataType = DataType::Float32; - armnn::TensorInfo inputInfo({1, 1, 10, 10 }, dataType); - armnn::TensorInfo outputInfo; - armnn::TensorInfo weightsInfo3x3({ 1, 1, 3, 3 }, dataType); - armnn::TensorInfo biasesInfo; + TensorInfo inputInfo({1, 1, 10, 10 }, dataType); + TensorInfo outputInfo; + TensorInfo weightsInfo3x3({ 1, 1, 3, 3 }, dataType); + TensorInfo biasesInfo; - armnn::DepthwiseConvolution2dDescriptor descriptor; - armnn::NeonLayerSupport layerSupport; + DepthwiseConvolution2dDescriptor descriptor; + NeonLayerSupport layerSupport; // Strides supported: 1,2,3 descriptor = MakeDepthwiseConv2dDesc(1, 1); @@ -254,14 +258,14 @@ BOOST_AUTO_TEST_CASE(DepthwiseConv2dUtils) weightsInfo3x3, biasesInfo)); // Supported weights shape 1x1 - armnn::TensorInfo weightsInfo1x1({ 1, 1, 1, 1 }, armnn::DataType::Float32); + TensorInfo weightsInfo1x1({ 1, 1, 1, 1 }, DataType::Float32); descriptor = MakeDepthwiseConv2dDesc(1, 1); outputInfo = CreateOutputTensorInfo(inputInfo, weightsInfo1x1, descriptor, dataType); BOOST_TEST(layerSupport.IsDepthwiseConvolutionSupported(inputInfo, outputInfo, descriptor, weightsInfo1x1, biasesInfo)); // Supported shape 2x2 - armnn::TensorInfo weightsInfo2x2({ 1, 1, 2, 2 }, armnn::DataType::Float32); + TensorInfo weightsInfo2x2({ 1, 1, 2, 2 }, DataType::Float32); descriptor = MakeDepthwiseConv2dDesc(1, 1); outputInfo = CreateOutputTensorInfo(inputInfo, weightsInfo2x2, descriptor, dataType); BOOST_TEST(layerSupport.IsDepthwiseConvolutionSupported(inputInfo, outputInfo, descriptor, @@ -282,22 +286,22 @@ ARMNN_AUTO_TEST_CASE(DequantizeOffsetUint8, DequantizeOffsetUint8Test) ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize3x3Stride2x4, SimpleMaxPooling2dSize3x3Stride2x4Test, true) ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dSize3x3Stride2x4Uint8, SimpleMaxPooling2dSize3x3Stride2x4Uint8Test, true) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2d, SimpleMaxPooling2dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dNhwc, SimpleMaxPooling2dTest, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8, SimpleMaxPooling2dUint8Test, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8Nhwc, SimpleMaxPooling2dUint8Test, armnn::DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2d, SimpleMaxPooling2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dNhwc, SimpleMaxPooling2dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8, SimpleMaxPooling2dUint8Test, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleMaxPooling2dUint8Nhwc, SimpleMaxPooling2dUint8Test, DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2d, SimpleAveragePooling2dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dNhwc, SimpleAveragePooling2dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8, SimpleAveragePooling2dUint8Test, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8Nhwc, SimpleAveragePooling2dUint8Test, armnn::DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2d, SimpleAveragePooling2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dNhwc, SimpleAveragePooling2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8, SimpleAveragePooling2dUint8Test, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleAveragePooling2dUint8Nhwc, SimpleAveragePooling2dUint8Test, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(LargeTensorsAveragePooling2d, LargeTensorsAveragePooling2dTest) ARMNN_AUTO_TEST_CASE(LargeTensorsAveragePooling2dUint8, LargeTensorsAveragePooling2dUint8Test) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2d, SimpleL2Pooling2dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dNeon, SimpleL2Pooling2dTest, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(UNSUPPORTED_SimpleL2Pooling2dUint8, SimpleL2Pooling2dUint8Test, armnn::DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2d, SimpleL2Pooling2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleL2Pooling2dNeon, SimpleL2Pooling2dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UNSUPPORTED_SimpleL2Pooling2dUint8, SimpleL2Pooling2dUint8Test, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(L2Pooling2dSize3Stride1, L2Pooling2dSize3Stride1Test) ARMNN_AUTO_TEST_CASE(UNSUPPORTED_L2Pooling2dSize3Stride1Uint8, L2Pooling2dSize3Stride1Uint8Test) @@ -381,7 +385,7 @@ ARMNN_AUTO_TEST_CASE(CopyViaSplitterUint8, CopyViaSplitterUint8Test) ARMNN_AUTO_TEST_CASE(SimpleConcat, ConcatTest) ARMNN_AUTO_TEST_CASE(ConcatUint8, ConcatUint8Test) ARMNN_AUTO_TEST_CASE(ConcatUint8DifferentInputOutputQParam, - ConcatDifferentInputOutputQParamTest, false) + ConcatDifferentInputOutputQParamTest, false) // Fully Connected ARMNN_AUTO_TEST_CASE(SimpleFullyConnected, FullyConnectedFloat32Test, false, false) @@ -389,8 +393,8 @@ ARMNN_AUTO_TEST_CASE(SimpleFullyConnectedWithBias, FullyConnectedFloat32Test, tr ARMNN_AUTO_TEST_CASE(SimpleFullyConnectedWithTranspose, FullyConnectedFloat32Test, false, true) ARMNN_AUTO_TEST_CASE(FullyConnectedLarge, FullyConnectedLargeTest, false) ARMNN_AUTO_TEST_CASE(FullyConnectedLargeTransposed, FullyConnectedLargeTest, true) -ARMNN_AUTO_TEST_CASE(FullyConnectedUint8, FullyConnectedTest, false) -ARMNN_AUTO_TEST_CASE(FullyConnectedBiasedUint8, FullyConnectedTest, true) +ARMNN_AUTO_TEST_CASE(FullyConnectedUint8, FullyConnectedTest, false) +ARMNN_AUTO_TEST_CASE(FullyConnectedBiasedUint8, FullyConnectedTest, true) // Add ARMNN_AUTO_TEST_CASE(SimpleAdd, AdditionTest) @@ -465,23 +469,23 @@ ARMNN_AUTO_TEST_CASE(Concatenation4dDiffShapeDim0Uint8, Concatenation4dDiffShape ARMNN_AUTO_TEST_CASE(Concatenation4dDiffShapeDim1Uint8, Concatenation4dDiffShapeDim1Uint8Test) ARMNN_AUTO_TEST_CASE(Concatenation4dDiffShapeDim3Uint8, Concatenation4dDiffShapeDim3Uint8Test, false) // L2 Normalization -ARMNN_AUTO_TEST_CASE(L2Normalization1d, L2Normalization1dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization2d, L2Normalization2dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization3d, L2Normalization3dTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization4d, L2Normalization4dTest, armnn::DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2Normalization1d, L2Normalization1dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2Normalization2d, L2Normalization2dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2Normalization3d, L2Normalization3dTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2Normalization4d, L2Normalization4dTest, DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2Normalization1dNhwc, L2Normalization1dTest, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization2dNhwc, L2Normalization2dTest, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization3dNhwc, L2Normalization3dTest, armnn::DataLayout::NHWC) -ARMNN_AUTO_TEST_CASE(L2Normalization4dNhwc, L2Normalization4dTest, armnn::DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(L2Normalization1dNhwc, L2Normalization1dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(L2Normalization2dNhwc, L2Normalization2dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(L2Normalization3dNhwc, L2Normalization3dTest, DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(L2Normalization4dNhwc, L2Normalization4dTest, DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(L2Normalization2dShape, L2Normalization2dShapeTest); -ARMNN_AUTO_TEST_CASE(L2NormalizationDefaultEpsilon, L2NormalizationDefaultEpsilonTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(L2NormalizationNonDefaultEpsilon, L2NormalizationNonDefaultEpsilonTest, armnn::DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2NormalizationDefaultEpsilon, L2NormalizationDefaultEpsilonTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(L2NormalizationNonDefaultEpsilon, L2NormalizationNonDefaultEpsilonTest, DataLayout::NCHW) // Floor -ARMNN_AUTO_TEST_CASE(SimpleFloor, SimpleFloorTest) +ARMNN_AUTO_TEST_CASE(SimpleFloor, SimpleFloorTest) // Greater ARMNN_AUTO_TEST_CASE(SimpleGreater, GreaterSimpleTest) @@ -507,20 +511,20 @@ ARMNN_AUTO_TEST_CASE(PadUint82dCustomPadding, PadUint82dCustomPaddingTest) ARMNN_AUTO_TEST_CASE(PadUint83d, PadUint83dTest) ARMNN_AUTO_TEST_CASE(PadUint84d, PadUint84dTest) -ARMNN_AUTO_TEST_CASE(Pad2dQSymm16, Pad2dTestCommon, 2.0f, 0, 0.0f) -ARMNN_AUTO_TEST_CASE(Pad2dQSymm16CustomPadding, Pad2dTestCommon, 2.0f, 0, 1.0f) -ARMNN_AUTO_TEST_CASE(Pad3dQSymm16, Pad3dTestCommon, 2.0f, 0) -ARMNN_AUTO_TEST_CASE(Pad4dQSymm16, Pad4dTestCommon, 2.0f, 0) +ARMNN_AUTO_TEST_CASE(Pad2dQSymm16, Pad2dTestCommon, 2.0f, 0, 0.0f) +ARMNN_AUTO_TEST_CASE(Pad2dQSymm16CustomPadding, Pad2dTestCommon, 2.0f, 0, 1.0f) +ARMNN_AUTO_TEST_CASE(Pad3dQSymm16, Pad3dTestCommon, 2.0f, 0) +ARMNN_AUTO_TEST_CASE(Pad4dQSymm16, Pad4dTestCommon, 2.0f, 0) // Permute -ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test) -ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test) -ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test) -ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test) +ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteTest) +ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet1Test, PermuteValueSet1Test) +ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet2Test, PermuteValueSet2Test) +ARMNN_AUTO_TEST_CASE(PermuteFloat32ValueSet3Test, PermuteValueSet3Test) +ARMNN_AUTO_TEST_CASE(SimplePermuteQASymm8, SimplePermuteTest) +ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet1Test, PermuteValueSet1Test) +ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet2Test, PermuteValueSet2Test) +ARMNN_AUTO_TEST_CASE(PermuteQASymm8ValueSet3Test, PermuteValueSet3Test) // Lstm ARMNN_AUTO_TEST_CASE(LstmLayerFloat32WithCifgWithPeepholeNoProjection, @@ -535,21 +539,21 @@ ARMNN_AUTO_TEST_CASE(LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNo ARMNN_AUTO_TEST_CASE(QuantizedLstm, QuantizedLstmTest) // Mean -ARMNN_AUTO_TEST_CASE(MeanSimpleFloat32, MeanSimpleTest) -ARMNN_AUTO_TEST_CASE(MeanSimpleAxisFloat32, MeanSimpleAxisTest) -ARMNN_AUTO_TEST_CASE(MeanKeepDimsFloat32, MeanKeepDimsTest) -ARMNN_AUTO_TEST_CASE(MeanMultipleDimsFloat32, MeanMultipleDimsTest) -ARMNN_AUTO_TEST_CASE(MeanVts1Float32, MeanVts1Test) -ARMNN_AUTO_TEST_CASE(MeanVts2Float32, MeanVts2Test) -ARMNN_AUTO_TEST_CASE(MeanVts3Float32, MeanVts3Test) - -ARMNN_AUTO_TEST_CASE(MeanSimpleQuantisedAsymm8, MeanSimpleTest) -ARMNN_AUTO_TEST_CASE(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest) -ARMNN_AUTO_TEST_CASE(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest) -ARMNN_AUTO_TEST_CASE(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest) -ARMNN_AUTO_TEST_CASE(MeanVts1QuantisedAsymm8, MeanVts1Test) -ARMNN_AUTO_TEST_CASE(MeanVts2QuantisedAsymm8, MeanVts2Test) -ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedAsymm8, MeanVts3Test) +ARMNN_AUTO_TEST_CASE(MeanSimpleFloat32, MeanSimpleTest) +ARMNN_AUTO_TEST_CASE(MeanSimpleAxisFloat32, MeanSimpleAxisTest) +ARMNN_AUTO_TEST_CASE(MeanKeepDimsFloat32, MeanKeepDimsTest) +ARMNN_AUTO_TEST_CASE(MeanMultipleDimsFloat32, MeanMultipleDimsTest) +ARMNN_AUTO_TEST_CASE(MeanVts1Float32, MeanVts1Test) +ARMNN_AUTO_TEST_CASE(MeanVts2Float32, MeanVts2Test) +ARMNN_AUTO_TEST_CASE(MeanVts3Float32, MeanVts3Test) + +ARMNN_AUTO_TEST_CASE(MeanSimpleQuantisedAsymm8, MeanSimpleTest) +ARMNN_AUTO_TEST_CASE(MeanSimpleAxisQuantisedAsymm8, MeanSimpleAxisTest) +ARMNN_AUTO_TEST_CASE(MeanKeepDimsQuantisedAsymm8, MeanKeepDimsTest) +ARMNN_AUTO_TEST_CASE(MeanMultipleDimsQuantisedAsymm8, MeanMultipleDimsTest) +ARMNN_AUTO_TEST_CASE(MeanVts1QuantisedAsymm8, MeanVts1Test) +ARMNN_AUTO_TEST_CASE(MeanVts2QuantisedAsymm8, MeanVts2Test) +ARMNN_AUTO_TEST_CASE(MeanVts3QuantisedAsymm8, MeanVts3Test) // Max ARMNN_AUTO_TEST_CASE(SimpleMaximum, MaximumSimpleTest) @@ -570,126 +574,126 @@ ARMNN_AUTO_TEST_CASE(SimpleNormalizationWithin, SimpleNormalizationWithinTest) ARMNN_AUTO_TEST_CASE(SimpleNormalizationAcrossNhwc, SimpleNormalizationAcrossNhwcTest) // Resize Bilinear - NCHW data layout -ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear, SimpleResizeBilinearTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearNop, ResizeBilinearNopTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin, ResizeBilinearSqMinTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMin, ResizeBilinearMinTest, armnn::DataLayout::NCHW) -ARMNN_AUTO_TEST_CASE(ResizeBilinearMag, ResizeBilinearMagTest, armnn::DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear, SimpleResizeBilinearTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(ResizeBilinearNop, ResizeBilinearNopTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin, ResizeBilinearSqMinTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(ResizeBilinearMin, ResizeBilinearMinTest, DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(ResizeBilinearMag, ResizeBilinearMagTest, DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8, - SimpleResizeBilinearTest, - armnn::DataLayout::NCHW) + SimpleResizeBilinearTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8, - ResizeBilinearNopTest, - armnn::DataLayout::NCHW) + ResizeBilinearNopTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8, - ResizeBilinearSqMinTest, - armnn::DataLayout::NCHW) + ResizeBilinearSqMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8, - ResizeBilinearMinTest, - armnn::DataLayout::NCHW) + ResizeBilinearMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8, - ResizeBilinearMagTest, - armnn::DataLayout::NCHW) + ResizeBilinearMagTest, + DataLayout::NCHW) // Resize Bilinear - NHWC data layout ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc, - ResizeBilinearNopTest, - armnn::DataLayout::NHWC) + ResizeBilinearNopTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc, - SimpleResizeBilinearTest, - armnn::DataLayout::NHWC) + SimpleResizeBilinearTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc, - ResizeBilinearSqMinTest, - armnn::DataLayout::NHWC) + ResizeBilinearSqMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc, - ResizeBilinearMinTest, - armnn::DataLayout::NHWC) + ResizeBilinearMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwc, - ResizeBilinearMagTest, - armnn::DataLayout::NHWC) + ResizeBilinearMagTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearNopUint8Nhwc, - ResizeBilinearNopTest, - armnn::DataLayout::NHWC) + ResizeBilinearNopTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearUint8Nhwc, - SimpleResizeBilinearTest, - armnn::DataLayout::NHWC) + SimpleResizeBilinearTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinUint8Nhwc, - ResizeBilinearSqMinTest, - armnn::DataLayout::NHWC) + ResizeBilinearSqMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearMinUint8Nhwc, - ResizeBilinearMinTest, - armnn::DataLayout::NHWC) + ResizeBilinearMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeBilinearMagUint8Nhwc, - ResizeBilinearMagTest, - armnn::DataLayout::NHWC) + ResizeBilinearMagTest, + DataLayout::NHWC) // Resize NearestNeighbor - NCHW ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighbor, - SimpleResizeNearestNeighborTest, - armnn::DataLayout::NCHW) + SimpleResizeNearestNeighborTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNop, - ResizeNearestNeighborNopTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborNopTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMin, - ResizeNearestNeighborSqMinTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborSqMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMin, - ResizeNearestNeighborMinTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMag, - ResizeNearestNeighborMagTest, - armnn::DataLayout::NCHW, 0.1f, 50, 0.1f, 50) + ResizeNearestNeighborMagTest, + DataLayout::NCHW, 0.1f, 50, 0.1f, 50) ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8, - SimpleResizeNearestNeighborTest, - armnn::DataLayout::NCHW) + SimpleResizeNearestNeighborTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8, - ResizeNearestNeighborNopTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborNopTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8, - ResizeNearestNeighborSqMinTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborSqMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8, - ResizeNearestNeighborMinTest, - armnn::DataLayout::NCHW) + ResizeNearestNeighborMinTest, + DataLayout::NCHW) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8, - ResizeNearestNeighborMagTest, - armnn::DataLayout::NCHW, 0.1f, 50, 0.1f, 50) + ResizeNearestNeighborMagTest, + DataLayout::NCHW, 0.1f, 50, 0.1f, 50) // Resize NearestNeighbor - NHWC ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopNhwc, - ResizeNearestNeighborNopTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborNopTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborNhwc, - SimpleResizeNearestNeighborTest, - armnn::DataLayout::NHWC) + SimpleResizeNearestNeighborTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinNhwc, - ResizeNearestNeighborSqMinTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborSqMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinNhwc, - ResizeNearestNeighborMinTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagNhwc, - ResizeNearestNeighborMagTest, - armnn::DataLayout::NHWC, 0.1f, 50, 0.1f, 50) + ResizeNearestNeighborMagTest, + DataLayout::NHWC, 0.1f, 50, 0.1f, 50) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborNopUint8Nhwc, - ResizeNearestNeighborNopTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborNopTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(SimpleResizeNearestNeighborUint8Nhwc, - SimpleResizeNearestNeighborTest, - armnn::DataLayout::NHWC) + SimpleResizeNearestNeighborTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborSqMinUint8Nhwc, - ResizeNearestNeighborSqMinTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborSqMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMinUint8Nhwc, - ResizeNearestNeighborMinTest, - armnn::DataLayout::NHWC) + ResizeNearestNeighborMinTest, + DataLayout::NHWC) ARMNN_AUTO_TEST_CASE(ResizeNearestNeighborMagUint8Nhwc, - ResizeNearestNeighborMagTest, - armnn::DataLayout::NHWC, 0.1f, 50, 0.1f, 50) + ResizeNearestNeighborMagTest, + DataLayout::NHWC, 0.1f, 50, 0.1f, 50) // Strided Slice ARMNN_AUTO_TEST_CASE(StridedSlice4DFloat32, StridedSlice4DFloat32Test) @@ -717,8 +721,8 @@ ARMNN_AUTO_TEST_CASE(QuantizeSimpleUint8, QuantizeSimpleUint8Test) ARMNN_AUTO_TEST_CASE(QuantizeClampUint8, QuantizeClampUint8Test) // PReLU -ARMNN_AUTO_TEST_CASE(PreluFloat32, PreluTest) -ARMNN_AUTO_TEST_CASE(PreluUint8, PreluTest) +ARMNN_AUTO_TEST_CASE(PreluFloat32, PreluTest) +ARMNN_AUTO_TEST_CASE(PreluUint8, PreluTest) // Stack ARMNN_AUTO_TEST_CASE(Stack0Axis, Stack0AxisTest) @@ -728,6 +732,109 @@ ARMNN_AUTO_TEST_CASE(Stack4dOutput3Axis, Stack4dOutput3AxisTest) ARMNN_AUTO_TEST_CASE(Stack5dOutput, Stack5dOutputTest) +// TransposeConvolution2d +ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNchw, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dFloatNhwc, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nchw, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(SimpleTransposeConvolution2dUint8Nhwc, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNchw, + SimpleTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dFloatNhwc, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nchw, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedSimpleTransposeConvolution2dUint8Nhwc, + SimpleTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNchw, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dFloatNhwc, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nchw, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(PaddedTransposeConvolution2dUint8Nhwc, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNchw, + PaddedTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dFloatNhwc, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nchw, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedPaddedTransposeConvolution2dUint8Nhwc, + PaddedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNchw, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dFloatNhwc, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nchw, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(StridedTransposeConvolution2dUint8Nhwc, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + +ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNchw, + StridedTransposeConvolution2dTest, + false, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dFloatNhwc, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) +ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nchw, + StridedTransposeConvolution2dTest, + true, + DataLayout::NCHW) +ARMNN_AUTO_TEST_CASE(UnbiasedStridedTransposeConvolution2dUint8Nhwc, + StridedTransposeConvolution2dTest, + true, + DataLayout::NHWC) + // ============================================================================ // COMPARE tests @@ -735,35 +842,35 @@ ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareConv2dWithReference, CompareConvolution2 ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareDepthwiseConv2dWithReferenceFloat32, CompareDepthwiseConvolution2dFloatTest, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareDepthwiseConv2dWithReferenceUint8, CompareDepthwiseConvolution2dUint8Test, - armnn::DataLayout::NCHW) + DataLayout::NCHW) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareDepthwiseConv2dWithReferenceFloat32Nhwc, CompareDepthwiseConvolution2dFloatTest, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareDepthwiseConv2dWithReferenceUint8Nhwc, CompareDepthwiseConvolution2dUint8Test, - armnn::DataLayout::NHWC) + DataLayout::NHWC) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareNormalizationWithinWithReference, CompareNormalizationTest, - armnn::NormalizationAlgorithmChannel::Within, - armnn::NormalizationAlgorithmMethod::LocalBrightness) + NormalizationAlgorithmChannel::Within, + NormalizationAlgorithmMethod::LocalBrightness) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareNormalizationAcrossWithReference, CompareNormalizationTest, - armnn::NormalizationAlgorithmChannel::Across, - armnn::NormalizationAlgorithmMethod::LocalBrightness) + NormalizationAlgorithmChannel::Across, + NormalizationAlgorithmMethod::LocalBrightness) -ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareMaxPooling2dWithReference, ComparePooling2dTest, armnn::PoolingAlgorithm::Max) +ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareMaxPooling2dWithReference, ComparePooling2dTest, PoolingAlgorithm::Max) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareMaxPooling2dWithReferenceUint8, ComparePooling2dUint8Test, - armnn::PoolingAlgorithm::Max) + PoolingAlgorithm::Max) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareAveragePooling2dWithReference, ComparePooling2dTest, - armnn::PoolingAlgorithm::Average) + PoolingAlgorithm::Average) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareAveragePooling2dWithReferenceUint8, ComparePooling2dUint8Test, - armnn::PoolingAlgorithm::Average) -ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareL2Pooling2dWithReference, ComparePooling2dTest, armnn::PoolingAlgorithm::L2) + PoolingAlgorithm::Average) +ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareL2Pooling2dWithReference, ComparePooling2dTest, PoolingAlgorithm::L2) ARMNN_COMPARE_REF_AUTO_TEST_CASE(UNSUPPORTED_CompareL2Pooling2dWithReferenceUint8, ComparePooling2dUint8Test, - armnn::PoolingAlgorithm::L2) + PoolingAlgorithm::L2) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareSoftmaxBeta1WithReference, CompareSoftmaxTest, 1.0f) ARMNN_COMPARE_REF_AUTO_TEST_CASE(CompareSoftmaxBeta2WithReference, CompareSoftmaxTest, 2.0f) @@ -784,34 +891,34 @@ ARMNN_COMPARE_REF_AUTO_TEST_CASE(ReLu6, CompareBoundedReLuTest, 6.0f, 0.0f) // FIXTURE tests ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareSigmoidActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::Sigmoid, 5u) + CompareActivationTest, ActivationFunction::Sigmoid, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareTanhActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::TanH, 5u) + CompareActivationTest, ActivationFunction::TanH, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareLinearActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::Linear, 5u) + CompareActivationTest, ActivationFunction::Linear, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareReLuActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::ReLu, 5u) + CompareActivationTest, ActivationFunction::ReLu, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareBoundedReLuActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::BoundedReLu, 5u) + CompareActivationTest, ActivationFunction::BoundedReLu, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareBoundedReLuActivationWithReferenceUint8, ActivationFixture, - CompareActivationUint8Test, armnn::ActivationFunction::BoundedReLu) + CompareActivationUint8Test, ActivationFunction::BoundedReLu) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareSoftReLuActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::SoftReLu, 1u) + CompareActivationTest, ActivationFunction::SoftReLu, 1u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareLeakyReLuActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::LeakyReLu, 5u) + CompareActivationTest, ActivationFunction::LeakyReLu, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareAbsActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::Abs, 5u) + CompareActivationTest, ActivationFunction::Abs, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareSqrtActivationWithReference, PositiveActivationFixture, - CompareActivationTest, armnn::ActivationFunction::Sqrt, 5u) + CompareActivationTest, ActivationFunction::Sqrt, 5u) ARMNN_COMPARE_REF_FIXTURE_TEST_CASE(CompareSquareActivationWithReference, ActivationFixture, - CompareActivationTest, armnn::ActivationFunction::Square, 5u) + CompareActivationTest, ActivationFunction::Square, 5u) BOOST_AUTO_TEST_SUITE_END() diff --git a/src/backends/neon/workloads/CMakeLists.txt b/src/backends/neon/workloads/CMakeLists.txt index 1115df1c20..e03a7137de 100644 --- a/src/backends/neon/workloads/CMakeLists.txt +++ b/src/backends/neon/workloads/CMakeLists.txt @@ -76,6 +76,8 @@ list(APPEND armnnNeonBackendWorkloads_sources NeonStridedSliceWorkload.hpp NeonSubtractionWorkload.cpp NeonSubtractionWorkload.hpp + NeonTransposeConvolution2dWorkload.cpp + NeonTransposeConvolution2dWorkload.hpp NeonWorkloads.hpp NeonWorkloadUtils.hpp ) diff --git a/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp new file mode 100644 index 0000000000..c62f71948c --- /dev/null +++ b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.cpp @@ -0,0 +1,109 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// +#include "NeonTransposeConvolution2dWorkload.hpp" + +#include "NeonWorkloadUtils.hpp" + +#include + +#include + +#include + +#include + +#include + +#include + +namespace armnn +{ + +using namespace armcomputetensorutils; + +arm_compute::Status NeonTransposeConvolution2dWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const TransposeConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional& biases) +{ + const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input, descriptor.m_DataLayout); + const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output, descriptor.m_DataLayout); + const arm_compute::TensorInfo aclWeightsInfo = BuildArmComputeTensorInfo(weights, descriptor.m_DataLayout); + + arm_compute::TensorInfo aclBiasesInfo; + arm_compute::TensorInfo *optionalAclBiasesInfo = nullptr; + + if (descriptor.m_BiasEnabled) + { + BOOST_ASSERT(biases.has_value()); + + aclBiasesInfo = BuildArmComputeTensorInfo(biases.value(), descriptor.m_DataLayout); + optionalAclBiasesInfo = &aclBiasesInfo; + } + + arm_compute::PadStrideInfo layerInfo = BuildArmComputePadStrideInfo(descriptor); + + return arm_compute::NEDeconvolutionLayer::validate(&aclInputInfo, + &aclWeightsInfo, + optionalAclBiasesInfo, + &aclOutputInfo, + layerInfo); +} + +NeonTransposeConvolution2dWorkload::NeonTransposeConvolution2dWorkload( + const TransposeConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info, + std::shared_ptr& memoryManager) + : BaseWorkload(descriptor, info) +{ + m_Data.ValidateInputsOutputs("NeonTransposeConvolution2dWorkload", 1, 1); + + arm_compute::ITensor& input = boost::polymorphic_downcast(m_Data.m_Inputs[0])->GetTensor(); + arm_compute::ITensor& output = boost::polymorphic_downcast(m_Data.m_Outputs[0])->GetTensor(); + + arm_compute::DataLayout aclDataLayout = ConvertDataLayout(m_Data.m_Parameters.m_DataLayout); + input.info()->set_data_layout(aclDataLayout); + output.info()->set_data_layout(aclDataLayout); + + m_KernelTensor = std::make_unique(); + BuildArmComputeTensor(*m_KernelTensor, m_Data.m_Weight->GetTensorInfo(), m_Data.m_Parameters.m_DataLayout); + + if (m_Data.m_Parameters.m_BiasEnabled) + { + m_BiasTensor = std::make_unique(); + BuildArmComputeTensor(*m_BiasTensor, m_Data.m_Bias->GetTensorInfo(), m_Data.m_Parameters.m_DataLayout); + } + + arm_compute::PadStrideInfo padStrideInfo = BuildArmComputePadStrideInfo(m_Data.m_Parameters); + + m_Layer = std::make_unique(memoryManager); + m_Layer->configure(&input, m_KernelTensor.get(), m_BiasTensor.get(), &output, padStrideInfo); + + BOOST_ASSERT(m_Layer); + + InitializeArmComputeTensorData(*m_KernelTensor, m_Data.m_Weight); + + if (m_Data.m_Parameters.m_BiasEnabled) + { + InitializeArmComputeTensorData(*m_BiasTensor, m_Data.m_Bias); + } + + m_Layer->prepare(); + FreeUnusedTensors(); +} + +void NeonTransposeConvolution2dWorkload::Execute() const +{ + ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonTransposeConvolution2dWorkload_Execute"); + m_Layer->run(); +} + +void NeonTransposeConvolution2dWorkload::FreeUnusedTensors() +{ + FreeTensorIfUnused(m_KernelTensor); + FreeTensorIfUnused(m_BiasTensor); +} + +} // namespace armnn diff --git a/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.hpp b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.hpp new file mode 100644 index 0000000000..995495e2ab --- /dev/null +++ b/src/backends/neon/workloads/NeonTransposeConvolution2dWorkload.hpp @@ -0,0 +1,45 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include + +#include +#include +#include + +#include + +#include + +namespace armnn +{ + +arm_compute::Status NeonTransposeConvolution2dWorkloadValidate(const TensorInfo& input, + const TensorInfo& output, + const TransposeConvolution2dDescriptor& descriptor, + const TensorInfo& weights, + const Optional& biases); + +class NeonTransposeConvolution2dWorkload : public BaseWorkload +{ +public: + NeonTransposeConvolution2dWorkload(const TransposeConvolution2dQueueDescriptor& descriptor, + const WorkloadInfo& info, + std::shared_ptr& memoryManager); + + void Execute() const override; + +private: + std::unique_ptr m_Layer; + + std::unique_ptr m_KernelTensor; + std::unique_ptr m_BiasTensor; + + void FreeUnusedTensors(); +}; + +} //namespace armnn diff --git a/src/backends/neon/workloads/NeonWorkloads.hpp b/src/backends/neon/workloads/NeonWorkloads.hpp index c201f6c3cd..210ba96e62 100644 --- a/src/backends/neon/workloads/NeonWorkloads.hpp +++ b/src/backends/neon/workloads/NeonWorkloads.hpp @@ -39,3 +39,4 @@ #include "NeonStackWorkload.hpp" #include "NeonStridedSliceWorkload.hpp" #include "NeonSubtractionWorkload.hpp" +#include "NeonTransposeConvolution2dWorkload.hpp" -- cgit v1.2.1