From 3ae3f978cf9ce3174609b7152af87acb410b0fe0 Mon Sep 17 00:00:00 2001 From: Keith Davis Date: Fri, 21 May 2021 16:33:48 +0100 Subject: MLCE-510 Add CpuRef Shape Operator to ArmNN * Add front end * Add reference workload * Serialization/Deserialization * Add unit tests * Update ArmNN Versioning Signed-off-by: Keith Davis Change-Id: I6fcb1fa341d6f08dea4003b13544e6e9f53fefd3 --- Android.mk | 1 + CMakeLists.txt | 3 + InstallationViaAptRepository.md | 4 +- docs/01_02_deserializer_serializer.dox | 1 + include/armnn/BackendHelper.hpp | 4 + include/armnn/DescriptorsFwd.hpp | 2 +- include/armnn/INetwork.hpp | 5 + include/armnn/Types.hpp | 8 +- include/armnn/Version.hpp | 2 +- include/armnn/backends/ILayerSupport.hpp | 4 + python/pyarmnn/README.md | 14 +- .../examples/image_classification/README.md | 2 +- python/pyarmnn/examples/object_detection/README.md | 2 +- .../pyarmnn/examples/speech_recognition/README.md | 2 +- python/pyarmnn/src/pyarmnn/_version.py | 4 +- python/pyarmnn/test/test_setup.py | 8 +- python/pyarmnn/test/test_version.py | 4 +- samples/ObjectDetection/Readme.md | 4 +- src/armnn/BackendHelper.cpp | 7 + src/armnn/LayersFwd.hpp | 2 + src/armnn/Network.cpp | 10 + src/armnn/Network.hpp | 2 + src/armnn/layers/ShapeLayer.cpp | 73 +++++ src/armnn/layers/ShapeLayer.hpp | 50 ++++ src/armnnDeserializer/Deserializer.cpp | 23 ++ src/armnnDeserializer/Deserializer.hpp | 1 + src/armnnDeserializer/test/DeserializeShape.cpp | 131 +++++++++ src/armnnSerializer/ArmnnSchema.fbs | 12 +- src/armnnSerializer/ArmnnSchema_generated.h | 88 +++++- src/armnnSerializer/Serializer.cpp | 16 ++ src/armnnSerializer/Serializer.hpp | 3 + src/armnnSerializer/test/SerializerTests.cpp | 25 ++ src/backends/backendsCommon/LayerSupportBase.cpp | 7 + src/backends/backendsCommon/LayerSupportBase.hpp | 4 + src/backends/backendsCommon/WorkloadData.cpp | 27 ++ src/backends/backendsCommon/WorkloadData.hpp | 5 + src/backends/backendsCommon/WorkloadFactory.cpp | 16 ++ src/backends/backendsCommon/WorkloadFactory.hpp | 3 + src/backends/backendsCommon/common.mk | 1 + src/backends/backendsCommon/test/CMakeLists.txt | 2 + .../test/IsLayerSupportedTestImpl.hpp | 2 + src/backends/backendsCommon/test/LayerTests.hpp | 1 + .../test/layerTests/ShapeTestImpl.cpp | 306 +++++++++++++++++++++ .../test/layerTests/ShapeTestImpl.hpp | 45 +++ src/backends/reference/RefLayerSupport.cpp | 18 ++ src/backends/reference/RefLayerSupport.hpp | 6 +- src/backends/reference/RefWorkloadFactory.cpp | 7 +- src/backends/reference/RefWorkloadFactory.hpp | 3 + src/backends/reference/test/RefLayerTests.cpp | 37 +++ src/backends/reference/workloads/CMakeLists.txt | 1 + .../reference/workloads/RefShapeWorkload.hpp | 48 ++++ src/backends/reference/workloads/RefWorkloads.hpp | 5 +- 52 files changed, 1017 insertions(+), 44 deletions(-) create mode 100644 src/armnn/layers/ShapeLayer.cpp create mode 100644 src/armnn/layers/ShapeLayer.hpp create mode 100644 src/armnnDeserializer/test/DeserializeShape.cpp create mode 100644 src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp create mode 100644 src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp create mode 100644 src/backends/reference/workloads/RefShapeWorkload.hpp diff --git a/Android.mk b/Android.mk index 69c6ee4352..aec32699b0 100644 --- a/Android.mk +++ b/Android.mk @@ -204,6 +204,7 @@ LOCAL_SRC_FILES := \ src/armnn/layers/ReduceLayer.cpp \ src/armnn/layers/ReshapeLayer.cpp \ src/armnn/layers/ResizeLayer.cpp \ + src/armnn/layers/ShapeLayer.cpp \ src/armnn/layers/SliceLayer.cpp \ src/armnn/layers/SoftmaxLayer.cpp \ src/armnn/layers/SpaceToBatchNdLayer.cpp \ diff --git a/CMakeLists.txt b/CMakeLists.txt index 17785a6cb7..054e4d7096 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -276,6 +276,8 @@ list(APPEND armnn_sources src/armnn/layers/ReshapeLayer.cpp src/armnn/layers/ResizeLayer.hpp src/armnn/layers/ResizeLayer.cpp + src/armnn/layers/ShapeLayer.cpp + src/armnn/layers/ShapeLayer.hpp src/armnn/layers/SliceLayer.cpp src/armnn/layers/SliceLayer.hpp src/armnn/layers/SoftmaxLayer.hpp @@ -757,6 +759,7 @@ if(BUILD_UNIT_TESTS) src/armnnDeserializer/test/DeserializeReshape.cpp src/armnnDeserializer/test/DeserializeResizeBilinear.cpp src/armnnDeserializer/test/DeserializeRsqrt.cpp + src/armnnDeserializer/test/DeserializeShape.cpp src/armnnDeserializer/test/DeserializeSlice.cpp src/armnnDeserializer/test/DeserializeSpaceToBatchNd.cpp src/armnnDeserializer/test/DeserializeStridedSlice.cpp diff --git a/InstallationViaAptRepository.md b/InstallationViaAptRepository.md index 16837be110..e4078603eb 100644 --- a/InstallationViaAptRepository.md +++ b/InstallationViaAptRepository.md @@ -113,7 +113,7 @@ In order to check for the latest available Arm NN version use apt-cache search: # Export the ARMNN_MAJOR_VERSION to the latest visible e.g. libarmnn25 to allow installation using the below examples - export ARMNN_MAJOR_VERSION=25 + export ARMNN_MAJOR_VERSION=26 ``` @@ -124,7 +124,7 @@ The easiest way to install all of the available packages for your systems archit sudo apt-get install -y python3-pyarmnn libarmnn-cpuacc-backend${ARMNN_MAJOR_VERSION} libarmnn-gpuacc-backend${ARMNN_MAJOR_VERSION} libarmnn-cpuref-backend${ARMNN_MAJOR_VERSION} # Verify installation via python: python3 -c "import pyarmnn as ann;print(ann.GetVersion())" - # Returns '{ARMNN_MAJOR_VERSION}.0.0' e.g. 25.0.0 + # Returns '{ARMNN_MAJOR_VERSION}.0.0' e.g. 26.0.0 ``` This will install PyArmNN and the three backends for Neon, Compute Library and our Reference Backend. It will also install their dependencies including the arm-compute-library package along with the Tensorflow Lite Parser diff --git a/docs/01_02_deserializer_serializer.dox b/docs/01_02_deserializer_serializer.dox index 1df3999d0a..811af1cfb5 100644 --- a/docs/01_02_deserializer_serializer.dox +++ b/docs/01_02_deserializer_serializer.dox @@ -63,6 +63,7 @@ The Arm NN SDK Serializer currently supports the following layers: - Reduce - Reshape - Resize +- Shape - Slice - Softmax - SpaceToBatchNd diff --git a/include/armnn/BackendHelper.hpp b/include/armnn/BackendHelper.hpp index 527d865694..093f822040 100644 --- a/include/armnn/BackendHelper.hpp +++ b/include/armnn/BackendHelper.hpp @@ -359,6 +359,10 @@ public: const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()); + bool IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()); + bool IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/include/armnn/DescriptorsFwd.hpp b/include/armnn/DescriptorsFwd.hpp index 4e7082e88f..9b22644c7b 100644 --- a/include/armnn/DescriptorsFwd.hpp +++ b/include/armnn/DescriptorsFwd.hpp @@ -38,10 +38,10 @@ struct ReshapeDescriptor; struct ResizeBilinearDescriptor; struct ResizeDescriptor; struct ReduceDescriptor; +struct SliceDescriptor; struct SoftmaxDescriptor; struct SpaceToBatchNdDescriptor; struct SpaceToDepthDescriptor; -struct SliceDescriptor; struct StackDescriptor; struct StandInDescriptor; struct StridedSliceDescriptor; diff --git a/include/armnn/INetwork.hpp b/include/armnn/INetwork.hpp index 8d94ed77f6..3c45262f1d 100644 --- a/include/armnn/INetwork.hpp +++ b/include/armnn/INetwork.hpp @@ -506,6 +506,11 @@ public: IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor, const char* name = nullptr); + /// Adds a shape layer to the network. + /// @param name - Optional name for the layer. + /// @return - Interface for configuring the layer. + IConnectableLayer* AddShapeLayer(const char* name = nullptr); + /// Adds a space to batch layer to the network. /// @param spaceToBatchNdDescriptor - Parameters for the space to batch operation. /// @param name - Optional name for the layer. diff --git a/include/armnn/Types.hpp b/include/armnn/Types.hpp index ac4dd31999..e7c17608ca 100644 --- a/include/armnn/Types.hpp +++ b/include/armnn/Types.hpp @@ -332,7 +332,8 @@ using InferenceTimingPair = std::pair; X(Addition) \ X(ArgMinMax) \ X(BatchNormalization) \ - X(BatchToSpaceNd) \ + X(BatchToSpaceNd) \ + X(Cast) \ X(Comparison) \ X(Concat) \ X(Constant) \ @@ -381,6 +382,7 @@ using InferenceTimingPair = std::pair; X(Rank) \ X(Resize) \ X(Reduce) \ + X(Shape) \ X(Slice) \ X(Softmax) \ X(SpaceToBatchNd) \ @@ -394,7 +396,7 @@ using InferenceTimingPair = std::pair; X(Transpose) \ X(TransposeConvolution2d) \ X(Unmap) \ - X(Cast) + /// When adding a new layer, adapt also the LastLayer enum value in the /// enum class LayerType below enum class LayerType @@ -403,7 +405,7 @@ enum class LayerType LIST_OF_LAYER_TYPE #undef X FirstLayer = Activation, - LastLayer = Cast + LastLayer = Unmap }; const char* GetLayerTypeAsCString(LayerType type); diff --git a/include/armnn/Version.hpp b/include/armnn/Version.hpp index 2139637b5b..5347097982 100644 --- a/include/armnn/Version.hpp +++ b/include/armnn/Version.hpp @@ -10,7 +10,7 @@ #define STRINGIFY_MACRO(s) #s // ArmNN version components -#define ARMNN_MAJOR_VERSION 25 +#define ARMNN_MAJOR_VERSION 26 #define ARMNN_MINOR_VERSION 0 #define ARMNN_PATCH_VERSION 0 diff --git a/include/armnn/backends/ILayerSupport.hpp b/include/armnn/backends/ILayerSupport.hpp index 52b6df7117..462668d738 100644 --- a/include/armnn/backends/ILayerSupport.hpp +++ b/include/armnn/backends/ILayerSupport.hpp @@ -351,6 +351,10 @@ public: const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const = 0; + virtual bool IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()) const = 0; + virtual bool IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/python/pyarmnn/README.md b/python/pyarmnn/README.md index 56ac78bb76..ee5ddf08d7 100644 --- a/python/pyarmnn/README.md +++ b/python/pyarmnn/README.md @@ -91,14 +91,14 @@ This step will put all generated files under `./src/pyarmnn/_generated` folder a ```bash $ python setup.py sdist ``` -As the result you will get `./dist/pyarmnn-25.0.0.tar.gz` file. As you can see it is platform independent. +As the result you will get `./dist/pyarmnn-26.0.0.tar.gz` file. As you can see it is platform independent. ##### 5. Build the binary package ```bash $ python setup.py bdist_wheel ``` -As the result you will get something like `./dist/pyarmnn-25.0.0-cp36-cp36m-linux_x86_64.whl` file. As you can see it +As the result you will get something like `./dist/pyarmnn-26.0.0-cp36-cp36m-linux_x86_64.whl` file. As you can see it is platform dependent. # PyArmNN installation @@ -107,8 +107,8 @@ PyArmNN can be distributed as a source package or a binary package (wheel). Binary package is platform dependent, the name of the package will indicate the platform it was built for, e.g.: -* Linux x86 64bit machine: pyarmnn-25.0.0-cp36-cp36m-*linux_x86_64*.whl -* Linux Aarch 64 bit machine: pyarmnn-25.0.0-cp36-cp36m-*linux_aarch64*.whl +* Linux x86 64bit machine: pyarmnn-26.0.0-cp36-cp36m-*linux_x86_64*.whl +* Linux Aarch 64 bit machine: pyarmnn-26.0.0-cp36-cp36m-*linux_aarch64*.whl The source package is platform independent but installation involves compilation of Arm NN python extension. You will need to have g++ compatible with C++ 14 standard and a python development library installed on the build machine. @@ -126,7 +126,7 @@ $ gcc --print-search-dirs ``` Install PyArmNN from binary by pointing to the wheel file: ```bash -$ pip install /path/to/pyarmnn-25.0.0-cp36-cp36m-linux_aarch64.whl +$ pip install /path/to/pyarmnn-26.0.0-cp36-cp36m-linux_aarch64.whl ``` ## Installing from source package @@ -143,7 +143,7 @@ $ export ARMNN_INCLUDE=/path/to/headers Install PyArmNN as follows: ```bash -$ pip install /path/to/pyarmnn-25.0.0.tar.gz +$ pip install /path/to/pyarmnn-26.0.0.tar.gz ``` If PyArmNN installation script fails to find Arm NN libraries it will raise an error like this @@ -157,7 +157,7 @@ $ pip show pyarmnn You can also verify it by running the following and getting output similar to below: ```bash $ python -c "import pyarmnn as ann;print(ann.GetVersion())" -'25.0.0' +'26.0.0' ``` # PyArmNN API overview diff --git a/python/pyarmnn/examples/image_classification/README.md b/python/pyarmnn/examples/image_classification/README.md index 27ed4cad8b..ea8f4c30a4 100644 --- a/python/pyarmnn/examples/image_classification/README.md +++ b/python/pyarmnn/examples/image_classification/README.md @@ -20,7 +20,7 @@ $ pip show pyarmnn You can also verify it by running the following and getting output similar to below: ```bash $ python -c "import pyarmnn as ann;print(ann.GetVersion())" -'25.0.0' +'26.0.0' ``` ##### Dependencies diff --git a/python/pyarmnn/examples/object_detection/README.md b/python/pyarmnn/examples/object_detection/README.md index 267d2e9ece..97bb164b17 100644 --- a/python/pyarmnn/examples/object_detection/README.md +++ b/python/pyarmnn/examples/object_detection/README.md @@ -23,7 +23,7 @@ $ pip show pyarmnn You can also verify it by running the following and getting output similar to below: ```bash $ python -c "import pyarmnn as ann;print(ann.GetVersion())" -'25.0.0' +'26.0.0' ``` ##### Dependencies diff --git a/python/pyarmnn/examples/speech_recognition/README.md b/python/pyarmnn/examples/speech_recognition/README.md index 7af1b188f4..cad4126c4d 100644 --- a/python/pyarmnn/examples/speech_recognition/README.md +++ b/python/pyarmnn/examples/speech_recognition/README.md @@ -18,7 +18,7 @@ You can also verify it by running the following and getting output similar to be ```bash $ python -c "import pyarmnn as ann;print(ann.GetVersion())" -'25.0.0' +'26.0.0' ``` ### Dependencies diff --git a/python/pyarmnn/src/pyarmnn/_version.py b/python/pyarmnn/src/pyarmnn/_version.py index f7fc8c9a9c..587efc4424 100644 --- a/python/pyarmnn/src/pyarmnn/_version.py +++ b/python/pyarmnn/src/pyarmnn/_version.py @@ -3,7 +3,7 @@ # SPDX-License-Identifier: MIT import os -version_info = (25, 0, 0) +version_info = (26, 0, 0) __dev_version_env = os.getenv("PYARMNN_DEV_VER", "") @@ -24,7 +24,7 @@ def check_armnn_version(installed_armnn_version: str, expected_armnn_version: st """Compares expected Arm NN version and Arm NN version used to build the package. Args: - installed_armnn_version (str): Arm NN version used to generate the package (e.g. 25.0.0) + installed_armnn_version (str): Arm NN version used to generate the package (e.g. 26.0.0) expected_armnn_version (str): Expected Arm NN version Returns: diff --git a/python/pyarmnn/test/test_setup.py b/python/pyarmnn/test/test_setup.py index f47addb1f5..8f1d81c093 100644 --- a/python/pyarmnn/test/test_setup.py +++ b/python/pyarmnn/test/test_setup.py @@ -87,15 +87,15 @@ def test_gcc_serch_path(): def test_armnn_version(): - check_armnn_version('25.0.0', '25.0.0') + check_armnn_version('26.0.0', '26.0.0') def test_incorrect_armnn_version(): with pytest.raises(AssertionError) as err: - check_armnn_version('25.0.0', '25.1.0') + check_armnn_version('26.0.0', '26.1.0') - assert 'Expected ArmNN version is 25.1.0 but installed ArmNN version is 25.0.0' in str(err.value) + assert 'Expected ArmNN version is 26.1.0 but installed ArmNN version is 26.0.0' in str(err.value) def test_armnn_version_patch_does_not_matter(): - check_armnn_version('25.0.0', '25.0.1') + check_armnn_version('26.0.0', '26.0.1') diff --git a/python/pyarmnn/test/test_version.py b/python/pyarmnn/test/test_version.py index ddb4abe0dc..9c21e82178 100644 --- a/python/pyarmnn/test/test_version.py +++ b/python/pyarmnn/test/test_version.py @@ -18,7 +18,7 @@ def test_dev_version(): importlib.reload(v) - assert "25.0.0.dev1" == v.__version__ + assert "26.0.0.dev1" == v.__version__ del os.environ["PYARMNN_DEV_VER"] del v @@ -30,7 +30,7 @@ def test_arm_version_not_affected(): importlib.reload(v) - assert "25.0.0" == v.__arm_ml_version__ + assert "26.0.0" == v.__arm_ml_version__ del os.environ["PYARMNN_DEV_VER"] del v diff --git a/samples/ObjectDetection/Readme.md b/samples/ObjectDetection/Readme.md index 408917eebc..025268a34f 100644 --- a/samples/ObjectDetection/Readme.md +++ b/samples/ObjectDetection/Readme.md @@ -168,8 +168,8 @@ From the build directory, copy the following to the host platform: The full list of libs after cross-compilation to copy on your board: ``` libarmnn.so -libarmnn.so.25 -libarmnn.so.25.0 +libarmnn.so.26 +libarmnn.so.26.0 libarmnnTfLiteParser.so libarmnnTfLiteParser.so.24.1 libavcodec.so diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp index be21412e97..a7bf419a7c 100644 --- a/src/armnn/BackendHelper.cpp +++ b/src/armnn/BackendHelper.cpp @@ -722,6 +722,13 @@ bool LayerSupportHandle::IsRsqrtSupported(const TensorInfo& input, return m_LayerSupport->IsRsqrtSupported(input, output, reasonIfUnsupported.value()); } +bool LayerSupportHandle::IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported) +{ + return m_LayerSupport->IsShapeSupported(input, output, reasonIfUnsupported.value()); +} + bool LayerSupportHandle::IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp index 19cd9bdf6c..cdbcaa7e90 100644 --- a/src/armnn/LayersFwd.hpp +++ b/src/armnn/LayersFwd.hpp @@ -60,6 +60,7 @@ #include "layers/ReduceLayer.hpp" #include "layers/ReshapeLayer.hpp" #include "layers/ResizeLayer.hpp" +#include "layers/ShapeLayer.hpp" #include "layers/SliceLayer.hpp" #include "layers/SoftmaxLayer.hpp" #include "layers/SpaceToBatchNdLayer.hpp" @@ -154,6 +155,7 @@ DECLARE_LAYER(Rank) DECLARE_LAYER(Reduce) DECLARE_LAYER(Reshape) DECLARE_LAYER(Resize) +DECLARE_LAYER(Shape) DECLARE_LAYER(Slice) DECLARE_LAYER(Softmax) DECLARE_LAYER(SpaceToBatchNd) diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp index 5807d1705a..71f19313b8 100644 --- a/src/armnn/Network.cpp +++ b/src/armnn/Network.cpp @@ -482,6 +482,11 @@ IConnectableLayer* INetwork::AddTransposeLayer(const TransposeDescriptor& transp return pNetworkImpl->AddTransposeLayer(transposeDescriptor, name); } +IConnectableLayer* INetwork::AddShapeLayer(const char* name) +{ + return pNetworkImpl->AddShapeLayer(name); +} + IConnectableLayer* INetwork::AddStackLayer(const StackDescriptor& descriptor, const char* name) { @@ -2099,6 +2104,11 @@ IConnectableLayer* NetworkImpl::AddResizeLayer(const ResizeDescriptor& resizeDes return m_Graph->AddLayer(resizeDescriptor, name); } +IConnectableLayer* NetworkImpl::AddShapeLayer(const char* name) +{ + return m_Graph->AddLayer(name); +} + IConnectableLayer* NetworkImpl::AddInstanceNormalizationLayer(const InstanceNormalizationDescriptor& desc, const char* name) { diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp index ad9b51cf35..e07075fbb5 100644 --- a/src/armnn/Network.hpp +++ b/src/armnn/Network.hpp @@ -250,6 +250,8 @@ public: IConnectableLayer* AddTransposeLayer(const TransposeDescriptor& transposeDescriptor, const char* name = nullptr); + IConnectableLayer* AddShapeLayer(const char* name = nullptr); + IConnectableLayer* AddStackLayer(const StackDescriptor& stackDescriptor, const char* name = nullptr); diff --git a/src/armnn/layers/ShapeLayer.cpp b/src/armnn/layers/ShapeLayer.cpp new file mode 100644 index 0000000000..4193fa9aab --- /dev/null +++ b/src/armnn/layers/ShapeLayer.cpp @@ -0,0 +1,73 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ShapeLayer.hpp" + +#include "LayerCloneBase.hpp" + +#include +#include + +#include +#include + +namespace armnn +{ + +ShapeLayer::ShapeLayer(const char* name) + : Layer(1, 1, LayerType::Shape, name) +{ +} + +std::unique_ptr ShapeLayer::CreateWorkload(const IWorkloadFactory& factory) const +{ + ShapeQueueDescriptor descriptor; + SetAdditionalInfo(descriptor); + + return factory.CreateShape(descriptor, PrepInfoAndDesc(descriptor)); +} + +ShapeLayer* ShapeLayer::Clone(Graph& graph) const +{ + return CloneBase(graph, GetName()); +} + +void ShapeLayer::ValidateTensorShapesFromInputs() +{ + VerifyLayerConnections(1, CHECK_LOCATION()); + + const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape(); + + VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod); + + auto inferredShape = InferOutputShapes({ GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() }); + + ARMNN_ASSERT(inferredShape.size() == 1); + + ValidateAndCopyShape(outputShape, inferredShape[0], m_ShapeInferenceMethod, "ShapeLayer"); +} + +std::vector ShapeLayer::InferOutputShapes(const std::vector& inputShapes) const +{ + IgnoreUnused(inputShapes); + ARMNN_ASSERT(inputShapes.size() == 1); + + TensorShape outputShape({ inputShapes[0].GetNumDimensions()} ); + + return std::vector({ outputShape }); +} + +void ShapeLayer::Accept(ILayerVisitor& visitor) const +{ + IgnoreUnused(visitor); + throw armnn::Exception("ShapeLayer VisitShapeLayer is not implemented"); +} + +void ShapeLayer::ExecuteStrategy(IStrategy& strategy) const +{ + strategy.ExecuteStrategy(this, BaseDescriptor(), {}, GetName()); +} + +} // namespace armnn diff --git a/src/armnn/layers/ShapeLayer.hpp b/src/armnn/layers/ShapeLayer.hpp new file mode 100644 index 0000000000..fee285c2f0 --- /dev/null +++ b/src/armnn/layers/ShapeLayer.hpp @@ -0,0 +1,50 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include "LayerWithParameters.hpp" + +namespace armnn +{ + +class ShapeLayer : public Layer +{ +public: + /// Makes a workload for the Shape type. + /// @param [in] graph The graph where this layer can be found. + /// @param [in] factory The workload factory which will create the workload. + /// @return A pointer to the created workload, or nullptr if not created. + virtual std::unique_ptr CreateWorkload(const IWorkloadFactory& factory) const override; + + /// Creates a dynamically-allocated copy of this layer. + /// @param [in] graph The graph into which this layer is being cloned. + ShapeLayer* Clone(Graph& graph) const override; + + /// Check if the input tensor shape(s) + /// will lead to a valid configuration of @ref ShapeLayer. + /// @param [in] shapeInferenceMethod Indicates if output shape shall be overwritten or just validated. + void ValidateTensorShapesFromInputs() override; + + /// By default returns inputShapes if the number of inputs are equal to number of outputs, + /// otherwise infers the output shapes from given input shapes and layer properties. + /// @param [in] inputShapes The input shapes layer has. + /// @return A vector to the inferred output shape. + std::vector InferOutputShapes(const std::vector& inputShapes) const override; + + void Accept(ILayerVisitor& visitor) const override; + + void ExecuteStrategy(IStrategy& strategy) const override; + +protected: + /// Constructor to create a ShapeLayer. + /// @param [in] name Optional name for the layer. + ShapeLayer(const char* name); + + /// Default destructor. + ~ShapeLayer() = default; +}; + +} // namespace armnn diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp index b5bf9daef0..af6ff842a7 100644 --- a/src/armnnDeserializer/Deserializer.cpp +++ b/src/armnnDeserializer/Deserializer.cpp @@ -257,6 +257,7 @@ m_ParserFunctions(Layer_MAX+1, &IDeserializer::DeserializerImpl::ParseUnsupporte m_ParserFunctions[Layer_ResizeBilinearLayer] = &DeserializerImpl::ParseResizeBilinear; m_ParserFunctions[Layer_ResizeLayer] = &DeserializerImpl::ParseResize; m_ParserFunctions[Layer_RsqrtLayer] = &DeserializerImpl::ParseRsqrt; + m_ParserFunctions[Layer_ShapeLayer] = &DeserializerImpl::ParseShape; m_ParserFunctions[Layer_SliceLayer] = &DeserializerImpl::ParseSlice; m_ParserFunctions[Layer_SoftmaxLayer] = &DeserializerImpl::ParseSoftmax; m_ParserFunctions[Layer_SpaceToBatchNdLayer] = &DeserializerImpl::ParseSpaceToBatchNd; @@ -377,6 +378,8 @@ LayerBaseRawPtr IDeserializer::DeserializerImpl::GetBaseLayer(const GraphPtr& gr return graphPtr->layers()->Get(layerIndex)->layer_as_ResizeLayer()->base(); case Layer::Layer_RsqrtLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_RsqrtLayer()->base(); + case Layer::Layer_ShapeLayer: + return graphPtr->layers()->Get(layerIndex)->layer_as_ShapeLayer()->base(); case Layer::Layer_SliceLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_SliceLayer()->base(); case Layer::Layer_SoftmaxLayer: @@ -2338,6 +2341,26 @@ void IDeserializer::DeserializerImpl::ParseResizeBilinear(GraphPtr graph, unsign RegisterOutputSlots(graph, layerIndex, layer); } +void IDeserializer::DeserializerImpl::ParseShape(GraphPtr graph, unsigned int layerIndex) +{ + CHECK_LAYERS(graph, 0, layerIndex); + + TensorRawPtrVector inputs = GetInputs(graph, layerIndex); + CHECK_VALID_SIZE(inputs.size(), 1); + + TensorRawPtrVector outputs = GetOutputs(graph, layerIndex); + CHECK_VALID_SIZE(outputs.size(), 1); + + auto layerName = GetLayerName(graph, layerIndex); + IConnectableLayer* layer = m_Network->AddShapeLayer( layerName.c_str()); + + armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]); + layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + RegisterInputSlots(graph, layerIndex, layer); + RegisterOutputSlots(graph, layerIndex, layer); +} + void IDeserializer::DeserializerImpl::ParseSoftmax(GraphPtr graph, unsigned int layerIndex) { CHECK_LAYERS(graph, 0, layerIndex); diff --git a/src/armnnDeserializer/Deserializer.hpp b/src/armnnDeserializer/Deserializer.hpp index 8f38058ae5..0b05e16849 100644 --- a/src/armnnDeserializer/Deserializer.hpp +++ b/src/armnnDeserializer/Deserializer.hpp @@ -125,6 +125,7 @@ private: void ParseResize(GraphPtr graph, unsigned int layerIndex); void ParseResizeBilinear(GraphPtr graph, unsigned int layerIndex); void ParseRsqrt(GraphPtr graph, unsigned int layerIndex); + void ParseShape(GraphPtr graph, unsigned int layerIndex); void ParseSlice(GraphPtr graph, unsigned int layerIndex); void ParseSoftmax(GraphPtr graph, unsigned int layerIndex); void ParseSpaceToBatchNd(GraphPtr graph, unsigned int layerIndex); diff --git a/src/armnnDeserializer/test/DeserializeShape.cpp b/src/armnnDeserializer/test/DeserializeShape.cpp new file mode 100644 index 0000000000..a20fb59699 --- /dev/null +++ b/src/armnnDeserializer/test/DeserializeShape.cpp @@ -0,0 +1,131 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include +#include "ParserFlatbuffersSerializeFixture.hpp" +#include + +#include + +BOOST_AUTO_TEST_SUITE(Deserializer) + +struct ShapeFixture : public ParserFlatbuffersSerializeFixture +{ + explicit ShapeFixture() + { + m_JsonString = R"( + { + layers: [ + { + layer_type: "InputLayer", + layer: { + base: { + base: { + layerName: "InputLayer", + layerType: "Input", + inputSlots: [ + + ], + outputSlots: [ + { + tensorInfo: { + dimensions: [ + 1, + 3, + 3, + 1 + ], + dataType: "Signed32", + quantizationScale: 0.0 + } + } + ] + } + } + } + }, + { + layer_type: "ShapeLayer", + layer: { + base: { + index: 1, + layerName: "shape", + layerType: "Shape", + inputSlots: [ + { + connection: { + sourceLayerIndex: 0, + outputSlotIndex: 0 + } + } + ], + outputSlots: [ + { + tensorInfo: { + dimensions: [ + 4 + ], + dataType: "Signed32", + quantizationScale: 0.0 + } + } + ] + } + } + }, + { + layer_type: "OutputLayer", + layer: { + base: { + base: { + index: 2, + layerName: "OutputLayer", + layerType: "Output", + inputSlots: [ + { + connection: { + sourceLayerIndex: 1, + outputSlotIndex: 0 + } + } + ], + outputSlots: [ + + ] + } + } + } + } + ], + inputIds: [ + 0 + ], + outputIds: [ + 0 + ], + featureVersions: { + bindingIdsScheme: 1 + } + } + )"; + Setup(); + } +}; + + +struct SimpleShapeFixture : ShapeFixture +{ + SimpleShapeFixture() : ShapeFixture() {} +}; + +BOOST_FIXTURE_TEST_CASE(DeserializeShape, SimpleShapeFixture) +{ + RunTest<1, armnn::DataType::Signed32>( + 0, + {{"InputLayer", { 1, 1, 1, 1, 1, 1, 1, 1, 1 }}}, + {{"OutputLayer",{ 1, 3, 3, 1 }}}); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs index 753c2443a4..32a9bba5ab 100644 --- a/src/armnnSerializer/ArmnnSchema.fbs +++ b/src/armnnSerializer/ArmnnSchema.fbs @@ -171,7 +171,8 @@ enum LayerType : uint { Rank = 58, LogicalBinary = 59, Reduce = 60, - Cast = 61 + Cast = 61, + Shape = 62 } // Base layer table to be used as part of other layers @@ -487,7 +488,7 @@ table ReshapeLayer { } table ReshapeDescriptor { - targetShape:[uint]; + targetShape:[uint]; } table PermuteLayer { @@ -499,6 +500,10 @@ table PermuteDescriptor { dimMappings:[uint]; } +table ShapeLayer { + base:LayerBase; +} + table SpaceToBatchNdLayer { base:LayerBase; descriptor:SpaceToBatchNdDescriptor; @@ -972,7 +977,8 @@ union Layer { RankLayer, LogicalBinaryLayer, ReduceLayer, - CastLayer + CastLayer, + ShapeLayer } table AnyLayer { diff --git a/src/armnnSerializer/ArmnnSchema_generated.h b/src/armnnSerializer/ArmnnSchema_generated.h index 675fcc6490..4a352ddb6c 100644 --- a/src/armnnSerializer/ArmnnSchema_generated.h +++ b/src/armnnSerializer/ArmnnSchema_generated.h @@ -4,6 +4,7 @@ // // automatically generated by the FlatBuffers compiler, do not modify + #ifndef FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ #define FLATBUFFERS_GENERATED_ARMNNSCHEMA_ARMNNSERIALIZER_H_ @@ -193,6 +194,9 @@ struct PermuteLayerBuilder; struct PermuteDescriptor; struct PermuteDescriptorBuilder; +struct ShapeLayer; +struct ShapeLayerBuilder; + struct SpaceToBatchNdLayer; struct SpaceToBatchNdLayerBuilder; @@ -735,11 +739,12 @@ enum LayerType { LayerType_LogicalBinary = 59, LayerType_Reduce = 60, LayerType_Cast = 61, + LayerType_Shape = 62, LayerType_MIN = LayerType_Addition, - LayerType_MAX = LayerType_Cast + LayerType_MAX = LayerType_Shape }; -inline const LayerType (&EnumValuesLayerType())[62] { +inline const LayerType (&EnumValuesLayerType())[63] { static const LayerType values[] = { LayerType_Addition, LayerType_Input, @@ -802,13 +807,14 @@ inline const LayerType (&EnumValuesLayerType())[62] { LayerType_Rank, LayerType_LogicalBinary, LayerType_Reduce, - LayerType_Cast + LayerType_Cast, + LayerType_Shape }; return values; } inline const char * const *EnumNamesLayerType() { - static const char * const names[63] = { + static const char * const names[64] = { "Addition", "Input", "Multiplication", @@ -871,13 +877,14 @@ inline const char * const *EnumNamesLayerType() { "LogicalBinary", "Reduce", "Cast", + "Shape", nullptr }; return names; } inline const char *EnumNameLayerType(LayerType e) { - if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_Cast)) return ""; + if (flatbuffers::IsOutRange(e, LayerType_Addition, LayerType_Shape)) return ""; const size_t index = static_cast(e); return EnumNamesLayerType()[index]; } @@ -1219,11 +1226,12 @@ enum Layer { Layer_LogicalBinaryLayer = 60, Layer_ReduceLayer = 61, Layer_CastLayer = 62, + Layer_ShapeLayer = 63, Layer_MIN = Layer_NONE, - Layer_MAX = Layer_CastLayer + Layer_MAX = Layer_ShapeLayer }; -inline const Layer (&EnumValuesLayer())[63] { +inline const Layer (&EnumValuesLayer())[64] { static const Layer values[] = { Layer_NONE, Layer_ActivationLayer, @@ -1287,13 +1295,14 @@ inline const Layer (&EnumValuesLayer())[63] { Layer_RankLayer, Layer_LogicalBinaryLayer, Layer_ReduceLayer, - Layer_CastLayer + Layer_CastLayer, + Layer_ShapeLayer }; return values; } inline const char * const *EnumNamesLayer() { - static const char * const names[64] = { + static const char * const names[65] = { "NONE", "ActivationLayer", "AdditionLayer", @@ -1357,13 +1366,14 @@ inline const char * const *EnumNamesLayer() { "LogicalBinaryLayer", "ReduceLayer", "CastLayer", + "ShapeLayer", nullptr }; return names; } inline const char *EnumNameLayer(Layer e) { - if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_CastLayer)) return ""; + if (flatbuffers::IsOutRange(e, Layer_NONE, Layer_ShapeLayer)) return ""; const size_t index = static_cast(e); return EnumNamesLayer()[index]; } @@ -1620,6 +1630,10 @@ template<> struct LayerTraits { static const Layer enum_value = Layer_CastLayer; }; +template<> struct LayerTraits { + static const Layer enum_value = Layer_ShapeLayer; +}; + bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer type); bool VerifyLayerVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); @@ -5180,6 +5194,49 @@ inline flatbuffers::Offset CreatePermuteDescriptorDirect( dimMappings__); } +struct ShapeLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ShapeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4 + }; + const armnnSerializer::LayerBase *base() const { + return GetPointer(VT_BASE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BASE) && + verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct ShapeLayerBuilder { + typedef ShapeLayer Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_base(flatbuffers::Offset base) { + fbb_.AddOffset(ShapeLayer::VT_BASE, base); + } + explicit ShapeLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ShapeLayerBuilder &operator=(const ShapeLayerBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateShapeLayer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset base = 0) { + ShapeLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + struct SpaceToBatchNdLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef SpaceToBatchNdLayerBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9567,6 +9624,9 @@ struct AnyLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const armnnSerializer::CastLayer *layer_as_CastLayer() const { return layer_type() == armnnSerializer::Layer_CastLayer ? static_cast(layer()) : nullptr; } + const armnnSerializer::ShapeLayer *layer_as_ShapeLayer() const { + return layer_type() == armnnSerializer::Layer_ShapeLayer ? static_cast(layer()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_LAYER_TYPE) && @@ -9824,6 +9884,10 @@ template<> inline const armnnSerializer::CastLayer *AnyLayer::layer_as inline const armnnSerializer::ShapeLayer *AnyLayer::layer_as() const { + return layer_as_ShapeLayer(); +} + struct AnyLayerBuilder { typedef AnyLayer Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -10292,6 +10356,10 @@ inline bool VerifyLayer(flatbuffers::Verifier &verifier, const void *obj, Layer auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case Layer_ShapeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp index 30a7e74a58..fd7f8dc7dc 100644 --- a/src/armnnSerializer/Serializer.cpp +++ b/src/armnnSerializer/Serializer.cpp @@ -1309,6 +1309,17 @@ void SerializerStrategy::SerializeNormalizationLayer(const armnn::IConnectableLa CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_NormalizationLayer); } +void SerializerStrategy::SerializeShapeLayer(const armnn::IConnectableLayer* layer, + const char* name) +{ + IgnoreUnused(name); + + auto shapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Shape); + auto shapeLayer = serializer::CreateShapeLayer(m_flatBufferBuilder, shapeBaseLayer); + + CreateAnyLayer(shapeLayer.o, serializer::Layer::Layer_ShapeLayer); +} + void SerializerStrategy::SerializeStackLayer(const armnn::IConnectableLayer* layer, const armnn::StackDescriptor& stackDescriptor, const char* name) @@ -2138,6 +2149,11 @@ void SerializerStrategy::ExecuteStrategy(const armnn::IConnectableLayer* layer, SerializeResizeLayer(layer, layerDescriptor, name); break; } + case armnn::LayerType::Shape: + { + SerializeShapeLayer(layer, name); + break; + } case armnn::LayerType::Slice: { const armnn::SliceDescriptor& layerDescriptor = diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp index 7bbcc2464e..c99e87d3e9 100644 --- a/src/armnnSerializer/Serializer.hpp +++ b/src/armnnSerializer/Serializer.hpp @@ -315,6 +315,9 @@ private: const armnn::NormalizationDescriptor& normalizationDescriptor, const char* name = nullptr); + void SerializeShapeLayer(const armnn::IConnectableLayer* layer, + const char* name = nullptr); + void SerializeSplitterLayer(const armnn::IConnectableLayer* layer, const armnn::ViewsDescriptor& viewsDescriptor, const char* name = nullptr); diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp index 8e7ca37cfa..98532d0cec 100644 --- a/src/armnnSerializer/test/SerializerTests.cpp +++ b/src/armnnSerializer/test/SerializerTests.cpp @@ -1951,6 +1951,31 @@ TEST_CASE("EnsureResizeBilinearBackwardCompatibility") deserializedNetwork->ExecuteStrategy(verifier); } +TEST_CASE("SerializeShape") +{ + const std::string layerName("shape"); + const armnn::TensorInfo inputInfo({1, 3, 3, 1}, armnn::DataType::Signed32); + const armnn::TensorInfo outputInfo({ 4 }, armnn::DataType::Signed32); + + armnn::INetworkPtr network = armnn::INetwork::Create(); + armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0); + armnn::IConnectableLayer* const shapeLayer = network->AddShapeLayer(layerName.c_str()); + armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0); + + inputLayer->GetOutputSlot(0).Connect(shapeLayer->GetInputSlot(0)); + shapeLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0)); + + inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo); + shapeLayer->GetOutputSlot(0).SetTensorInfo(outputInfo); + + armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network)); + CHECK(deserializedNetwork); + + LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo}); + + deserializedNetwork->ExecuteStrategy(verifier); +} + TEST_CASE("SerializeSlice") { const std::string layerName{"slice"}; diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp index 2e171f98ae..8a24e1161b 100644 --- a/src/backends/backendsCommon/LayerSupportBase.cpp +++ b/src/backends/backendsCommon/LayerSupportBase.cpp @@ -557,6 +557,13 @@ bool LayerSupportBase::IsRsqrtSupported(const TensorInfo&, // input return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); } +bool LayerSupportBase::IsShapeSupported(const TensorInfo&, // input + const TensorInfo&, // output + Optional reasonIfUnsupported) const +{ + return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported); +} + bool LayerSupportBase::IsSliceSupported(const TensorInfo&, // input const TensorInfo&, // output const SliceDescriptor&, // descriptor diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp index a4f972f961..0277a782a1 100644 --- a/src/backends/backendsCommon/LayerSupportBase.hpp +++ b/src/backends/backendsCommon/LayerSupportBase.hpp @@ -344,6 +344,10 @@ public: const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp index 44a6a17b37..8c78136185 100644 --- a/src/backends/backendsCommon/WorkloadData.cpp +++ b/src/backends/backendsCommon/WorkloadData.cpp @@ -2805,6 +2805,33 @@ void MergeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName, "input_0", "output"); } +void ShapeQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const +{ + const std::string& descriptorName{"ShapeQueueDescriptor"}; + + ValidateNumInputs(workloadInfo, descriptorName, 1); + ValidateNumOutputs(workloadInfo, descriptorName, 1); + + const TensorInfo& inputTensorInfo = workloadInfo.m_InputTensorInfos[0]; + const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0]; + + std::vector supportedTypes = + { + DataType::BFloat16, + DataType::Float16, + DataType::Float32, + DataType::QAsymmS8, + DataType::QAsymmU8, + DataType::QAsymmS8, + DataType::QSymmS8, + DataType::QSymmS16, + DataType::Signed32 + }; + + ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName); + ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName); +} + void SwitchQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const { const std::string& descriptorName{"SwitchQueueDescriptor"}; diff --git a/src/backends/backendsCommon/WorkloadData.hpp b/src/backends/backendsCommon/WorkloadData.hpp index 11ce2cb44f..36653bdc0d 100644 --- a/src/backends/backendsCommon/WorkloadData.hpp +++ b/src/backends/backendsCommon/WorkloadData.hpp @@ -690,4 +690,9 @@ struct ReduceQueueDescriptor : QueueDescriptorWithParameters void Validate(const WorkloadInfo& workloadInfo) const; }; +struct ShapeQueueDescriptor : QueueDescriptor +{ + void Validate(const WorkloadInfo& workloadInfo) const; +}; + } // namespace armnn diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp index c5fc9d0fe2..61ad20995b 100644 --- a/src/backends/backendsCommon/WorkloadFactory.cpp +++ b/src/backends/backendsCommon/WorkloadFactory.cpp @@ -1003,6 +1003,16 @@ bool IWorkloadFactory::IsLayerConfigurationSupported(const BackendId& backendId, reason); break; } + case LayerType::Shape: + { + const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo(); + const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo(); + + result = layerSupportObject.IsShapeSupported(OverrideDataType(input, dataType), + OverrideDataType(output, dataType), + reason); + break; + } case LayerType::Slice: { auto cLayer = PolymorphicDowncast(&layer); @@ -1673,6 +1683,12 @@ std::unique_ptr IWorkloadFactory::CreateRsqrt(const RsqrtQueueDescrip return std::unique_ptr(); } +std::unique_ptr IWorkloadFactory::CreateShape(const ShapeQueueDescriptor& /*descriptor*/, + const WorkloadInfo& /*info*/) const +{ + return std::unique_ptr(); +} + std::unique_ptr IWorkloadFactory::CreateSlice(const SliceQueueDescriptor& /*descriptor*/, const WorkloadInfo& /*info*/) const { diff --git a/src/backends/backendsCommon/WorkloadFactory.hpp b/src/backends/backendsCommon/WorkloadFactory.hpp index 42360d37ff..1987b9b664 100644 --- a/src/backends/backendsCommon/WorkloadFactory.hpp +++ b/src/backends/backendsCommon/WorkloadFactory.hpp @@ -252,6 +252,9 @@ public: virtual std::unique_ptr CreateRsqrt(const RsqrtQueueDescriptor& descriptor, const WorkloadInfo& info) const; + virtual std::unique_ptr CreateShape(const ShapeQueueDescriptor& descriptor, + const WorkloadInfo& info) const; + virtual std::unique_ptr CreateSlice(const SliceQueueDescriptor& descriptor, const WorkloadInfo& info) const; diff --git a/src/backends/backendsCommon/common.mk b/src/backends/backendsCommon/common.mk index 73a16d00e1..ff9375dec1 100644 --- a/src/backends/backendsCommon/common.mk +++ b/src/backends/backendsCommon/common.mk @@ -85,6 +85,7 @@ COMMON_TEST_SOURCES := \ test/layerTests/SliceTestImpl.cpp \ test/layerTests/QuantizeTestImpl.cpp \ test/layerTests/SinTestImpl.cpp \ + test/layerTests/ShapeTestImpl.cpp \ test/layerTests/SoftmaxTestImpl.cpp \ test/layerTests/SpaceToBatchNdTestImpl.cpp \ test/layerTests/SpaceToDepthTestImpl.cpp \ diff --git a/src/backends/backendsCommon/test/CMakeLists.txt b/src/backends/backendsCommon/test/CMakeLists.txt index 82381a8b84..162368fd43 100644 --- a/src/backends/backendsCommon/test/CMakeLists.txt +++ b/src/backends/backendsCommon/test/CMakeLists.txt @@ -157,6 +157,8 @@ list(APPEND armnnBackendsCommonUnitTests_sources layerTests/RsqrtTestImpl.hpp layerTests/SinTestImpl.cpp layerTests/SinTestImpl.hpp + layerTests/ShapeTestImpl.cpp + layerTests/ShapeTestImpl.cpp layerTests/SliceTestImpl.cpp layerTests/SliceTestImpl.hpp layerTests/SoftmaxTestImpl.cpp diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp index 5a05ee1d85..adc7bc4c3c 100644 --- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp +++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp @@ -663,6 +663,8 @@ DECLARE_LAYER_POLICY_2_PARAM(Resize) DECLARE_LAYER_POLICY_2_PARAM(Reshape) +DECLARE_LAYER_POLICY_1_PARAM(Shape) + DECLARE_LAYER_POLICY_2_PARAM(Slice) DECLARE_LAYER_POLICY_2_PARAM(Softmax) diff --git a/src/backends/backendsCommon/test/LayerTests.hpp b/src/backends/backendsCommon/test/LayerTests.hpp index 4ae6553362..46eb6ee2a5 100644 --- a/src/backends/backendsCommon/test/LayerTests.hpp +++ b/src/backends/backendsCommon/test/LayerTests.hpp @@ -55,6 +55,7 @@ #include #include #include +#include #include #include #include diff --git a/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp new file mode 100644 index 0000000000..d6c03141ab --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.cpp @@ -0,0 +1,306 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ShapeTestImpl.hpp" + +#include +#include +#include + +#include + +template +LayerTestResult ShapeTest( + armnn::TensorInfo inputTensorInfo, + std::vector input, + armnn::TensorInfo outputTensorInfo, + std::vector expectedOutputData, + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + IgnoreUnused(memoryManager); + + std::vector actualOutput(outputTensorInfo.GetNumElements()); + + std::unique_ptr inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo); + std::unique_ptr outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo); + + armnn::ShapeQueueDescriptor data; + armnn::WorkloadInfo info; + AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get()); + AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get()); + + std::unique_ptr workload = workloadFactory.CreateShape(data, info); + + inputHandle->Allocate(); + outputHandle->Allocate(); + + CopyDataToITensorHandle(inputHandle.get(), input.data()); + + workload->Execute(); + + CopyDataFromITensorHandle(actualOutput.data(), outputHandle.get()); + + return LayerTestResult(actualOutput, + expectedOutputData, + outputHandle->GetShape(), + outputTensorInfo.GetShape()); +} + +template +LayerTestResult ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo({ 1 }, ArmnnType, 1.0f, 0); + armnn::TensorInfo outputTensorInfo({ 1 }, armnn::DataType::Signed32); + + auto input = ConvertToDataType({ 1.0f }, inputTensorInfo); + + return ShapeTest(inputTensorInfo, input, outputTensorInfo, { 1 }, workloadFactory, memoryManager, + tensorHandleFactory); +} + +template +LayerTestResult ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo({ 1, 2 }, ArmnnType, 1.0f, 0); + armnn::TensorInfo outputTensorInfo({ 2 }, armnn::DataType::Signed32); + + auto input = ConvertToDataType({ 1.0f, 1.0f }, inputTensorInfo); + + return ShapeTest(inputTensorInfo, input, outputTensorInfo, { 1, 2 }, workloadFactory, memoryManager, + tensorHandleFactory); +} + +template +LayerTestResult ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo({ 1, 2, 3 }, ArmnnType, 1.0f, 0); + armnn::TensorInfo outputTensorInfo({ 3 }, armnn::DataType::Signed32); + + auto input = ConvertToDataType({ 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, inputTensorInfo); + + return ShapeTest(inputTensorInfo, input, outputTensorInfo, { 1, 2, 3 }, workloadFactory, memoryManager, + tensorHandleFactory); +} + +template +LayerTestResult ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory) +{ + armnn::TensorInfo inputTensorInfo({ 2, 2, 3, 2 }, ArmnnType, 1.0f, 0); + armnn::TensorInfo outputTensorInfo({ 4 }, armnn::DataType::Signed32); + + auto input = ConvertToDataType({ 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f }, + inputTensorInfo); + + return ShapeTest(inputTensorInfo, input, outputTensorInfo, { 2, 2, 3, 2 }, workloadFactory, memoryManager, + tensorHandleFactory); +} + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template LayerTestResult +ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); \ No newline at end of file diff --git a/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp new file mode 100644 index 0000000000..85f7c0a453 --- /dev/null +++ b/src/backends/backendsCommon/test/layerTests/ShapeTestImpl.hpp @@ -0,0 +1,45 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include "LayerTestResult.hpp" + +#include + +#include +#include + +template +LayerTestResult ShapeTest( + armnn::TensorInfo inputTensorInfo, + std::vector input, + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ShapeDimSize1Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ShapeDimSize2Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ShapeDimSize3Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); + +template> +LayerTestResult ShapeDimSize4Test( + armnn::IWorkloadFactory& workloadFactory, + const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager, + const armnn::ITensorHandleFactory& tensorHandleFactory); diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp index 14a40f9d5d..1b05c4e0f4 100644 --- a/src/backends/reference/RefLayerSupport.cpp +++ b/src/backends/reference/RefLayerSupport.cpp @@ -1859,6 +1859,24 @@ bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input, reasonIfUnsupported); } +bool RefLayerSupport::IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported) const +{ + IgnoreUnused(input); + bool supported = true; + + std::array supportedTypes = + { + DataType::Signed32 + }; + + supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported, + "Reference Shape: output type not supported"); + + return supported; +} + bool RefLayerSupport::IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp index 7a95bb06ac..c060f79b5a 100644 --- a/src/backends/reference/RefLayerSupport.hpp +++ b/src/backends/reference/RefLayerSupport.hpp @@ -297,12 +297,16 @@ public: const TensorInfo& output, const ResizeDescriptor& descriptor, Optional reasonIfUnsupported = EmptyOptional()) const override; - + ARMNN_DEPRECATED_MSG("Use IsElementwiseUnarySupported instead") bool IsRsqrtSupported(const TensorInfo& input, const TensorInfo& output, Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsShapeSupported(const TensorInfo& input, + const TensorInfo& output, + Optional reasonIfUnsupported = EmptyOptional()) const override; + bool IsSliceSupported(const TensorInfo& input, const TensorInfo& output, const SliceDescriptor& descriptor, diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp index 8e3bbe468f..606f531630 100644 --- a/src/backends/reference/RefWorkloadFactory.cpp +++ b/src/backends/reference/RefWorkloadFactory.cpp @@ -7,7 +7,6 @@ #include #include #include -#include #include "RefWorkloadFactory.hpp" #include "RefBackendId.hpp" #include "workloads/RefWorkloads.hpp" @@ -626,6 +625,12 @@ std::unique_ptr RefWorkloadFactory::CreateRsqrt(const RsqrtQueueDescr return CreateElementwiseUnary(elementwiseUnaryDescriptor, info); } +std::unique_ptr RefWorkloadFactory::CreateShape(const ShapeQueueDescriptor& descriptor, + const WorkloadInfo& info) const +{ + return std::make_unique(descriptor, info); +} + std::unique_ptr RefWorkloadFactory::CreateSlice(const SliceQueueDescriptor& descriptor, const WorkloadInfo& info) const { diff --git a/src/backends/reference/RefWorkloadFactory.hpp b/src/backends/reference/RefWorkloadFactory.hpp index 734c5e49c3..2beffa77f3 100644 --- a/src/backends/reference/RefWorkloadFactory.hpp +++ b/src/backends/reference/RefWorkloadFactory.hpp @@ -243,6 +243,9 @@ public: std::unique_ptr CreateRsqrt(const RsqrtQueueDescriptor& descriptor, const WorkloadInfo& info) const override; + std::unique_ptr CreateShape(const ShapeQueueDescriptor& descriptor, + const WorkloadInfo& info) const override; + std::unique_ptr CreateSlice(const SliceQueueDescriptor& descriptor, const WorkloadInfo& info) const override; diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp index 1cc6fa8d36..45e3717268 100644 --- a/src/backends/reference/test/RefLayerTests.cpp +++ b/src/backends/reference/test/RefLayerTests.cpp @@ -1733,6 +1733,43 @@ ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_2, DepthToSpaceTest2, DataLayout::NHWC); ARMNN_AUTO_TEST_CASE(DepthToSpaceNhwcInt16_4, DepthToSpaceTest4, DataLayout::NHWC); +// Shape +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Float16, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Float32, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QAsymmU8, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1Signed32, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QSymmS16, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QSymmS8, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1QAsymmS8, ShapeDimSize1Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize1BFloat16, ShapeDimSize1Test) + +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Float16, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Float32, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QAsymmU8, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2Signed32, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QSymmS16, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QSymmS8, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2QAsymmS8, ShapeDimSize2Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize2BFloat16, ShapeDimSize2Test) + +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Float16, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Float32, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QAsymmU8, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3Signed32, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QSymmS16, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QSymmS8, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3QAsymmS8, ShapeDimSize3Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize3BFloat16, ShapeDimSize3Test) + +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Float16, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Float32, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QAsymmU8, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4Signed32, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QSymmS16, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QSymmS8, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4QAsymmS8, ShapeDimSize4Test) +ARMNN_AUTO_TEST_CASE_WITH_THF(ShapeDimSize4BFloat16, ShapeDimSize4Test) + // SpaceToDepth ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNchwAsymmQ8, SpaceToDepthNchwAsymmQ8Test) ARMNN_AUTO_TEST_CASE_WITH_THF(SpaceToDepthNhwcAsymmQ8, SpaceToDepthNhwcAsymmQ8Test) diff --git a/src/backends/reference/workloads/CMakeLists.txt b/src/backends/reference/workloads/CMakeLists.txt index 09e02e67bd..7a769e5246 100644 --- a/src/backends/reference/workloads/CMakeLists.txt +++ b/src/backends/reference/workloads/CMakeLists.txt @@ -143,6 +143,7 @@ list(APPEND armnnRefBackendWorkloads_sources RefResizeBilinearWorkload.hpp RefResizeWorkload.cpp RefResizeWorkload.hpp + RefShapeWorkload.hpp RefSliceWorkload.cpp RefSliceWorkload.hpp RefSoftmaxWorkload.cpp diff --git a/src/backends/reference/workloads/RefShapeWorkload.hpp b/src/backends/reference/workloads/RefShapeWorkload.hpp new file mode 100644 index 0000000000..8e2a410b0c --- /dev/null +++ b/src/backends/reference/workloads/RefShapeWorkload.hpp @@ -0,0 +1,48 @@ +// +// Copyright © 2021 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#pragma once + +#include +#include + +#include "RefWorkloadUtils.hpp" + +namespace armnn +{ + +struct RefShapeWorkload : public BaseWorkload +{ +public: + using BaseWorkload::BaseWorkload; + virtual void Execute() const override + { + Execute(m_Data.m_Inputs, m_Data.m_Outputs); + } + void ExecuteAsync(WorkingMemDescriptor& workingMemDescriptor) override + { + Execute(workingMemDescriptor.m_Inputs, workingMemDescriptor.m_Outputs); + } + +private: + void Execute(std::vector inputs, std::vector outputs) const + { + const TensorShape Shape = GetTensorInfo(inputs[0]).GetShape(); + + const TensorInfo& outputInfo = GetTensorInfo(outputs[0]); + + unsigned int numBytes = + GetTensorInfo(inputs[0]).GetNumDimensions() * GetDataTypeSize(outputInfo.GetDataType()); + + std::memcpy(outputs[0]->Map(), &Shape, numBytes); + outputs[0]->Unmap(); + } +}; + +} //namespace armnn + + + + diff --git a/src/backends/reference/workloads/RefWorkloads.hpp b/src/backends/reference/workloads/RefWorkloads.hpp index d3995f2b82..afe63d13c0 100644 --- a/src/backends/reference/workloads/RefWorkloads.hpp +++ b/src/backends/reference/workloads/RefWorkloads.hpp @@ -35,10 +35,10 @@ #include "RefDequantizeWorkload.hpp" #include "RefElementwiseWorkload.hpp" #include "RefElementwiseUnaryWorkload.hpp" +#include "RefFakeQuantizationFloat32Workload.hpp" #include "RefFillWorkload.hpp" -#include "RefFullyConnectedWorkload.hpp" #include "RefFloorWorkload.hpp" -#include "RefFakeQuantizationFloat32Workload.hpp" +#include "RefFullyConnectedWorkload.hpp" #include "RefGatherWorkload.hpp" #include "RefInstanceNormalizationWorkload.hpp" #include "RefL2NormalizationWorkload.hpp" @@ -59,6 +59,7 @@ #include "RefReshapeWorkload.hpp" #include "RefResizeBilinearWorkload.hpp" #include "RefResizeWorkload.hpp" +#include "RefShapeWorkload.hpp" #include "RefSliceWorkload.hpp" #include "RefSplitterWorkload.hpp" #include "RefSoftmaxWorkload.hpp" -- cgit v1.2.1