aboutsummaryrefslogtreecommitdiff
path: root/src/armnn
diff options
context:
space:
mode:
Diffstat (limited to 'src/armnn')
-rw-r--r--src/armnn/InternalTypes.hpp3
-rw-r--r--src/armnn/LayersFwd.hpp2
-rw-r--r--src/armnn/Network.cpp6
-rw-r--r--src/armnn/Network.hpp3
-rw-r--r--src/armnn/layers/SpaceToDepthLayer.cpp85
-rw-r--r--src/armnn/layers/SpaceToDepthLayer.hpp50
-rw-r--r--src/armnn/test/LayerValidateOutputTest.cpp29
7 files changed, 174 insertions, 4 deletions
diff --git a/src/armnn/InternalTypes.hpp b/src/armnn/InternalTypes.hpp
index 9a215e6d39..377fb925f1 100644
--- a/src/armnn/InternalTypes.hpp
+++ b/src/armnn/InternalTypes.hpp
@@ -55,6 +55,7 @@ enum class LayerType
Rsqrt,
Softmax,
SpaceToBatchNd,
+ SpaceToDepth,
Splitter,
StridedSlice,
Subtraction,
@@ -66,6 +67,6 @@ enum class LayerType
const char* GetLayerTypeAsCString(LayerType type);
using Coordinates = std::array<unsigned int, MaxNumOfTensorDimensions>;
-using Dimensions = std::array<unsigned int, MaxNumOfTensorDimensions>;
+using Dimensions = std::array<unsigned int, MaxNumOfTensorDimensions>;
}
diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp
index 40330f2234..de9717caeb 100644
--- a/src/armnn/LayersFwd.hpp
+++ b/src/armnn/LayersFwd.hpp
@@ -47,6 +47,7 @@
#include "layers/RsqrtLayer.hpp"
#include "layers/SoftmaxLayer.hpp"
#include "layers/SpaceToBatchNdLayer.hpp"
+#include "layers/SpaceToDepthLayer.hpp"
#include "layers/SplitterLayer.hpp"
#include "layers/StridedSliceLayer.hpp"
#include "layers/SubtractionLayer.hpp"
@@ -120,6 +121,7 @@ DECLARE_LAYER(ResizeBilinear)
DECLARE_LAYER(Rsqrt)
DECLARE_LAYER(Softmax)
DECLARE_LAYER(SpaceToBatchNd)
+DECLARE_LAYER(SpaceToDepth)
DECLARE_LAYER(Splitter)
DECLARE_LAYER(StridedSlice)
DECLARE_LAYER(Subtraction)
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index 6bd365bab8..3e7d4d54dd 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -835,6 +835,12 @@ IConnectableLayer* Network::AddSpaceToBatchNdLayer(const SpaceToBatchNdDescripto
return m_Graph->AddLayer<SpaceToBatchNdLayer>(spaceToBatchNdDescriptor, name);
}
+IConnectableLayer* Network::AddSpaceToDepthLayer(const SpaceToDepthDescriptor& spaceToDepthDescriptor,
+ const char* name)
+{
+ return m_Graph->AddLayer<SpaceToDepthLayer>(spaceToDepthDescriptor, name);
+}
+
IConnectableLayer* Network::AddFloorLayer(const char* name)
{
return m_Graph->AddLayer<FloorLayer>(name);
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index 52a27141c5..2648c3f48f 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -147,6 +147,9 @@ public:
IConnectableLayer* AddSpaceToBatchNdLayer(const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
const char* name = nullptr) override;
+ IConnectableLayer* AddSpaceToDepthLayer(const SpaceToDepthDescriptor& spaceToDepthDescriptor,
+ const char* name = nullptr) override;
+
IConnectableLayer* AddFloorLayer(const char* name = nullptr) override;
IConnectableLayer* AddOutputLayer(LayerBindingId id, const char* name = nullptr) override;
diff --git a/src/armnn/layers/SpaceToDepthLayer.cpp b/src/armnn/layers/SpaceToDepthLayer.cpp
new file mode 100644
index 0000000000..b24490f82f
--- /dev/null
+++ b/src/armnn/layers/SpaceToDepthLayer.cpp
@@ -0,0 +1,85 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "SpaceToDepthLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/TypesUtils.hpp>
+
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+#include <DataLayoutIndexed.hpp>
+
+#include <numeric>
+
+using namespace armnnUtils;
+
+namespace armnn
+{
+
+SpaceToDepthLayer::SpaceToDepthLayer(const SpaceToDepthDescriptor param, const char* name)
+ : LayerWithParameters(1, 1, LayerType::SpaceToDepth, param, name)
+{}
+
+std::unique_ptr<IWorkload> SpaceToDepthLayer::CreateWorkload(const Graph& graph,
+ const IWorkloadFactory& factory) const
+{
+ SpaceToDepthQueueDescriptor descriptor;
+ descriptor.m_Parameters.m_BlockSize = m_Param.m_BlockSize;
+ descriptor.m_Parameters.m_DataLayout = m_Param.m_DataLayout;
+
+ return factory.CreateSpaceToDepth(descriptor, PrepInfoAndDesc(descriptor, graph));
+}
+
+SpaceToDepthLayer* SpaceToDepthLayer::Clone(Graph& graph) const
+{
+ return CloneBase<SpaceToDepthLayer>(graph, m_Param, GetName());
+}
+
+std::vector<TensorShape> SpaceToDepthLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+ BOOST_ASSERT(inputShapes.size() == 1);
+
+ TensorShape inputShape = inputShapes[0];
+ TensorShape outputShape(inputShape);
+
+ outputShape[0] = inputShape[0];
+
+ DataLayoutIndexed dimensionIndices{m_Param.m_DataLayout};
+ unsigned int hIndex = dimensionIndices.GetHeightIndex();
+ unsigned int wIndex = dimensionIndices.GetWidthIndex();
+ unsigned int cIndex = dimensionIndices.GetChannelsIndex();
+
+ outputShape[hIndex] = inputShape[hIndex] / m_Param.m_BlockSize;
+ outputShape[wIndex] = inputShape[wIndex] / m_Param.m_BlockSize;
+
+ outputShape[cIndex] = inputShape[cIndex] * m_Param.m_BlockSize * m_Param.m_BlockSize;
+
+ return std::vector<TensorShape>({ outputShape });
+}
+
+void SpaceToDepthLayer::ValidateTensorShapesFromInputs()
+{
+ VerifyLayerConnections(1, CHECK_LOCATION());
+
+ std::vector<TensorShape> inferredShapes = InferOutputShapes({
+ GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() });
+
+ BOOST_ASSERT(inferredShapes.size() == 1);
+
+ ConditionalThrowIfNotEqual<LayerValidationException>(
+ "SpaceToDepthLayer: TensorShape set on OutputSlot[0] does not match the inferred shape.",
+ GetOutputSlot(0).GetTensorInfo().GetShape(),
+ inferredShapes[0]);
+}
+
+void SpaceToDepthLayer::Accept(ILayerVisitor& visitor) const
+{
+ visitor.VisitSpaceToDepthLayer(this, GetParameters(), GetName());
+}
+
+} // namespace armnn \ No newline at end of file
diff --git a/src/armnn/layers/SpaceToDepthLayer.hpp b/src/armnn/layers/SpaceToDepthLayer.hpp
new file mode 100644
index 0000000000..b83a9e0170
--- /dev/null
+++ b/src/armnn/layers/SpaceToDepthLayer.hpp
@@ -0,0 +1,50 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+/// This layer represents a SpaceToDepth operation.
+class SpaceToDepthLayer : public LayerWithParameters<SpaceToDepthDescriptor>
+{
+public:
+ /// Makes a workload for the SpaceToDepth 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<IWorkload> CreateWorkload(const Graph& graph,
+ 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.
+ SpaceToDepthLayer* Clone(Graph& graph) const 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<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+
+ /// Check if the input tensor shape(s)
+ /// will lead to a valid configuration of @ref SpaceToDepthLayer.
+ void ValidateTensorShapesFromInputs() override;
+
+ void Accept(ILayerVisitor& visitor) const override;
+
+protected:
+ /// Constructor to create a SpaceToDepthLayer.
+ /// @param [in] param SpaceToDepthDescriptor to configure the SpaceToDepthLayer operation.
+ /// @param [in] name Optional name for the layer.
+ SpaceToDepthLayer(const SpaceToDepthDescriptor param, const char* name);
+
+ /// Default destructor
+ ~SpaceToDepthLayer() = default;
+};
+
+} // namespace armnn
diff --git a/src/armnn/test/LayerValidateOutputTest.cpp b/src/armnn/test/LayerValidateOutputTest.cpp
index 999844e252..acefd51110 100644
--- a/src/armnn/test/LayerValidateOutputTest.cpp
+++ b/src/armnn/test/LayerValidateOutputTest.cpp
@@ -4,11 +4,12 @@
//
#include <armnn/ArmNN.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/test/unit_test.hpp>
-#include <layers/BatchToSpaceNdLayer.hpp>
#include <Graph.hpp>
+#include <layers/BatchToSpaceNdLayer.hpp>
+#include <layers/SpaceToDepthLayer.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(LayerValidateOutput)
@@ -35,4 +36,26 @@ BOOST_AUTO_TEST_CASE(TestBatchToSpaceInferOutputShape)
BOOST_CHECK(expectedShape == batchToSpaceLayer->InferOutputShapes(shapes).at(0));
}
+BOOST_AUTO_TEST_CASE(TestSpaceToDepthInferOutputShape)
+{
+ armnn::Graph graph;
+
+ armnn::SpaceToDepthDescriptor descriptor;
+ descriptor.m_BlockSize = 2;
+ descriptor.m_DataLayout = armnn::DataLayout::NHWC;
+
+ armnn::SpaceToDepthLayer* const spaceToDepthLayer =
+ graph.AddLayer<armnn::SpaceToDepthLayer>(descriptor, "spaceToDepth");
+
+ std::vector<armnn::TensorShape> shapes;
+ const std::vector<unsigned int> dimSizes{ 1, 16, 8, 3 };
+ armnn::TensorShape shape(4, dimSizes.data());
+ shapes.push_back(shape);
+
+ const std::vector<unsigned int> expectedDimSizes{ 1, 8, 4, 12 };
+ armnn::TensorShape expectedShape(4, expectedDimSizes.data());
+
+ BOOST_CHECK(expectedShape == spaceToDepthLayer->InferOutputShapes(shapes).at(0));
+}
+
BOOST_AUTO_TEST_SUITE_END()
generated by cgit v1.2.1 (git 2.23.0) at 2024-06-06 11:07:45 +0000