IVGCVSW-7879 Change REVERSE_V2 from LayerWithParameters with 1 input, to Layer with 2 inputs
* Changing ReverseV2 to use two inputs
* This is required by the backends
* The ReverseV2Descriptor was removed
* Tests updated
* Added a Run<> templatefor inputs with different data types
Signed-off-by: Tracy Narine <tracy.narine@arm.com>
Change-Id: I22f947de829b4b3da6bda3a74f4ffdef4052cc25
diff --git a/include/armnn/BackendHelper.hpp b/include/armnn/BackendHelper.hpp
index 6f804cb..6181ba5 100644
--- a/include/armnn/BackendHelper.hpp
+++ b/include/armnn/BackendHelper.hpp
@@ -360,9 +360,9 @@
const ResizeDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional());
- bool IsReverseV2Supported(const TensorInfo& input,
+ bool IsReverseV2Supported(const TensorInfo& input0,
+ const TensorInfo& input1,
const TensorInfo& output,
- const ReverseV2Descriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional());
bool IsShapeSupported(const TensorInfo& input,
diff --git a/include/armnn/Descriptors.hpp b/include/armnn/Descriptors.hpp
index 27ca501..9ff894f 100644
--- a/include/armnn/Descriptors.hpp
+++ b/include/armnn/Descriptors.hpp
@@ -1620,28 +1620,4 @@
const TensorShape& tensorShape);
};
-struct ReverseV2Descriptor : BaseDescriptor
-{
- ReverseV2Descriptor()
- : m_Axis()
- , m_MaxDimension(4)
- {}
-
- ReverseV2Descriptor(std::vector<int32_t> axis)
- : m_Axis(axis)
- , m_MaxDimension(4)
- {}
-
- bool operator ==(const ReverseV2Descriptor& rhs) const
- {
- return m_Axis == rhs.m_Axis;
- }
-
- /// The indices of the dimensions to reverse
- std::vector<int32_t> m_Axis;
- /// The max dimension supported in the lower levels of code
- uint32_t m_MaxDimension;
-
-};
-
} // namespace armnn
diff --git a/include/armnn/DescriptorsFwd.hpp b/include/armnn/DescriptorsFwd.hpp
index 4e9621d..2c25a49 100644
--- a/include/armnn/DescriptorsFwd.hpp
+++ b/include/armnn/DescriptorsFwd.hpp
@@ -42,7 +42,6 @@
struct ReshapeDescriptor;
struct ResizeDescriptor;
struct ReduceDescriptor;
-struct ReverseV2Descriptor;
struct SliceDescriptor;
struct SoftmaxDescriptor;
struct SpaceToBatchNdDescriptor;
diff --git a/include/armnn/INetwork.hpp b/include/armnn/INetwork.hpp
index e311fa8..e20dd1c 100644
--- a/include/armnn/INetwork.hpp
+++ b/include/armnn/INetwork.hpp
@@ -838,11 +838,9 @@
const char* name = nullptr);
/// Add a ReverseV2 layer to the network
- /// @param descriptor - Parameters for the ReverseV2 operation
/// @param name - Optional name for the layer
/// @return - Interface for configuring the layer
- IConnectableLayer* AddReverseV2Layer(const ReverseV2Descriptor& descriptor,
- const char* name = nullptr);
+ IConnectableLayer* AddReverseV2Layer(const char* name = nullptr);
void ExecuteStrategy(IStrategy& strategy) const;
diff --git a/include/armnn/backends/WorkloadData.hpp b/include/armnn/backends/WorkloadData.hpp
index fe59fca..e7d5e0e 100644
--- a/include/armnn/backends/WorkloadData.hpp
+++ b/include/armnn/backends/WorkloadData.hpp
@@ -750,7 +750,7 @@
void Validate(const WorkloadInfo& workloadInfo) const;
};
-struct ReverseV2QueueDescriptor : QueueDescriptorWithParameters<ReverseV2Descriptor>
+struct ReverseV2QueueDescriptor : QueueDescriptor
{
void Validate(const WorkloadInfo& workloadInfo) const;
};
diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp
index 404d278..18184fb 100644
--- a/src/armnn/BackendHelper.cpp
+++ b/src/armnn/BackendHelper.cpp
@@ -1211,16 +1211,16 @@
reasonIfUnsupported);
}
-bool LayerSupportHandle::IsReverseV2Supported(const armnn::TensorInfo &input,
+bool LayerSupportHandle::IsReverseV2Supported(const armnn::TensorInfo &input0,
+ const armnn::TensorInfo &input1,
const armnn::TensorInfo &output,
- const armnn::ReverseV2Descriptor &descriptor,
Optional<std::string &> reasonIfUnsupported)
{
- TensorInfos infos{input, output};
+ TensorInfos infos{input0, input1, output};
return m_LayerSupport->IsLayerSupported(LayerType::ReverseV2,
infos,
- descriptor,
+ BaseDescriptor(),
EmptyOptional(),
EmptyOptional(),
reasonIfUnsupported);
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index ae5bde1..010fa00 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -639,10 +639,9 @@
return pNetworkImpl->AddBatchMatMulLayer(descriptor, name);
}
-IConnectableLayer* INetwork::AddReverseV2Layer(const ReverseV2Descriptor &descriptor,
- const char *name)
+IConnectableLayer* INetwork::AddReverseV2Layer(const char *name)
{
- return pNetworkImpl->AddReverseV2Layer(descriptor, name);
+ return pNetworkImpl->AddReverseV2Layer(name);
}
void INetwork::ExecuteStrategy(IStrategy& strategy) const
@@ -2930,9 +2929,9 @@
return m_Graph->AddLayer<BatchMatMulLayer>(desc, name);
}
-IConnectableLayer* NetworkImpl::AddReverseV2Layer(const ReverseV2Descriptor &desc, const char *name)
+IConnectableLayer* NetworkImpl::AddReverseV2Layer(const char *name)
{
- return m_Graph->AddLayer<ReverseV2Layer>(desc, name);
+ return m_Graph->AddLayer<ReverseV2Layer>(name);
}
IConnectableLayer* NetworkImpl::AddPrecompiledLayer(const PreCompiledDescriptor& preCompiledDescriptor,
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index fc3ae42..ae287f3 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -188,8 +188,7 @@
IConnectableLayer* AddReshapeLayer(const ReshapeDescriptor& reshapeDescriptor,
const char* name = nullptr);
- IConnectableLayer* AddReverseV2Layer(const ReverseV2Descriptor& ReverseV2Descriptor,
- const char* name = nullptr);
+ IConnectableLayer* AddReverseV2Layer(const char* name = nullptr);
IConnectableLayer* AddShapeLayer(const char* name = nullptr);
diff --git a/src/armnn/layers/ReverseV2Layer.cpp b/src/armnn/layers/ReverseV2Layer.cpp
index 201e198..e1160b6 100644
--- a/src/armnn/layers/ReverseV2Layer.cpp
+++ b/src/armnn/layers/ReverseV2Layer.cpp
@@ -10,9 +10,10 @@
namespace armnn
{
-ReverseV2Layer::ReverseV2Layer(const armnn::ReverseV2Descriptor ¶m, const char *name)
- : LayerWithParameters(1, 1, LayerType::ReverseV2, param, name)
-{}
+ReverseV2Layer::ReverseV2Layer(const char* name)
+ : Layer(2, 1, LayerType::ReverseV2, name)
+{
+}
std::unique_ptr<IWorkload> ReverseV2Layer::CreateWorkload(const armnn::IWorkloadFactory &factory) const
{
@@ -24,27 +25,48 @@
ReverseV2Layer* ReverseV2Layer::Clone(armnn::Graph &graph) const
{
- auto layer = CloneBase<ReverseV2Layer>(graph, m_Param, GetName());
+ auto layer = CloneBase<ReverseV2Layer>(graph, GetName());
return std::move(layer);
}
-/// Use the default Layer::InferOutputShape method
+std::vector<TensorShape> ReverseV2Layer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+ ARMNN_ASSERT(inputShapes.size() == 2);
+
+ const auto inputDims = inputShapes[0].GetNumDimensions();
+
+ std::vector<unsigned int> dimSizes(inputDims);
+ for (unsigned i=0; i<inputDims; i++)
+ {
+ dimSizes[i] = inputShapes[0][i];
+ }
+
+ TensorShape outputShape({ inputDims, dimSizes.data() });
+
+ return std::vector<TensorShape>({ outputShape });
+}
void ReverseV2Layer::ValidateTensorShapesFromInputs()
{
- VerifyLayerConnections(1, CHECK_LOCATION());
+ VerifyLayerConnections(2, CHECK_LOCATION());
const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();
VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);
auto inferredShapes = InferOutputShapes({
- GetInputSlot(0).GetTensorInfo().GetShape() });
+ GetInputSlot(0).GetTensorInfo().GetShape(),
+ GetInputSlot(1).GetTensorInfo().GetShape()});
ARMNN_ASSERT(inferredShapes.size() == 1);
ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "ReverseV2Layer");
}
-}
\ No newline at end of file
+void ReverseV2Layer::ExecuteStrategy(IStrategy& strategy) const
+{
+ strategy.ExecuteStrategy(this, BaseDescriptor(), {}, GetName());
+}
+
+}
diff --git a/src/armnn/layers/ReverseV2Layer.hpp b/src/armnn/layers/ReverseV2Layer.hpp
index 046670e..7dc0656 100644
--- a/src/armnn/layers/ReverseV2Layer.hpp
+++ b/src/armnn/layers/ReverseV2Layer.hpp
@@ -11,7 +11,7 @@
{
/// This layer represents a ReverseV2 operation.
- class ReverseV2Layer : public LayerWithParameters<ReverseV2Descriptor>
+ class ReverseV2Layer : public Layer
{
public:
/// Makes a workload for the ReverseV2 type.
@@ -28,19 +28,18 @@
/// otherwise infers the output shapes from given input shapes and layer properties.
/// @param [in] inputShapes The vector of input shapes for ReverseV2.
/// @return A vector to the inferred output shape.
-
- /// Use the default Layer::InferOutputShape method
- // std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+ 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 ReverseV2Layer.
void ValidateTensorShapesFromInputs() override;
+ void ExecuteStrategy(IStrategy& strategy) const override;
+
protected:
/// Constructor to create a ReverseV2Layer.
- /// @param [in] param ReverseV2Descriptor to configure the ReverseV2 operation.
/// @param [in] name Optional name for the layer.
- ReverseV2Layer(const ReverseV2Descriptor& param, const char* name);
+ ReverseV2Layer(const char* name);
/// Default destructor
~ReverseV2Layer() = default;
diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp
index d125ef5..1e40c63 100644
--- a/src/armnnDeserializer/Deserializer.cpp
+++ b/src/armnnDeserializer/Deserializer.cpp
@@ -2749,20 +2749,13 @@
CHECK_LAYERS(graph, 0, layerIndex);
TensorRawPtrVector inputs = GetInputs(graph, layerIndex);
- CHECK_VALID_SIZE(inputs.size(), 1);
+ CHECK_VALID_SIZE(inputs.size(), 2);
TensorRawPtrVector outputs = GetOutputs(graph, layerIndex);
CHECK_VALID_SIZE(outputs.size(), 1);
- auto flatBufferDescriptor = graph->layers()->Get(layerIndex)->layer_as_ReverseV2Layer()->descriptor();
- auto flatBufferAxis = flatBufferDescriptor->axis();
-
- armnn::ReverseV2Descriptor descriptor;
- descriptor.m_Axis =
- std::vector<int32_t>(flatBufferAxis->begin(), flatBufferAxis->end());
-
auto layerName = GetLayerName(graph, layerIndex);
- IConnectableLayer* layer = m_Network->AddReverseV2Layer(descriptor, layerName.c_str());
+ IConnectableLayer* layer = m_Network->AddReverseV2Layer(layerName.c_str());
armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
diff --git a/src/armnnDeserializer/test/DeserializeReverseV2.cpp b/src/armnnDeserializer/test/DeserializeReverseV2.cpp
index 73816f8..b6f207c 100644
--- a/src/armnnDeserializer/test/DeserializeReverseV2.cpp
+++ b/src/armnnDeserializer/test/DeserializeReverseV2.cpp
@@ -14,61 +14,96 @@
{
struct ReverseV2Fixture : public ParserFlatbuffersSerializeFixture
{
- explicit ReverseV2Fixture(const std::string& inputShape,
+ explicit ReverseV2Fixture(const std::string& inputShape0,
+ const std::string& inputShape1,
const std::string& outputShape,
- const std::string& dataType,
- const std::string& axis)
+ const std::string& dataType0,
+ const std::string& dataType1)
{
m_JsonString = R"(
{
- inputIds: [0],
- outputIds: [2],
- layers: [
+ inputIds: [0, 1],
+ outputIds: [3],
+ layers:
+ [
{
layer_type: "InputLayer",
layer: {
- base: {
- layerBindingId: 0,
- base: {
- index: 0,
- layerName: "InputLayer",
- layerType: "Input",
- inputSlots: [{
+ base: {
+ layerBindingId: 0,
+ base: {
index: 0,
- connection: {sourceLayerIndex:0, outputSlotIndex:0 },
- }],
- outputSlots: [{
- index: 0,
- tensorInfo: {
- dimensions: )" + inputShape + R"(,
- dataType: )" + dataType + R"(
- }
- }]
- }
- }
+ layerName: "InputLayer0",
+ layerType: "Input",
+ inputSlots:
+ [{
+ index: 0,
+ connection: {sourceLayerIndex:0, outputSlotIndex:0 },
+ }],
+ outputSlots:
+ [ {
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + inputShape0 + R"(,
+ dataType: )" + dataType0 + R"(
+ }
+ }]
+ }
+ }
}
},
{
- layer_type: "ReverseV2Layer",
+ layer_type: "InputLayer",
layer: {
- base: {
- index: 1,
- layerName: "ReverseV2Layer",
- layerType: "ReverseV2",
- inputSlots: [{
- index: 0,
- connection: {sourceLayerIndex:0, outputSlotIndex:0 },
- }],
- outputSlots: [{
- index: 0,
- tensorInfo: {
- dimensions: )" + outputShape + R"(,
- dataType: )" + dataType + R"(
+ base: {
+ layerBindingId: 1,
+ base: {
+ index:1,
+ layerName: "InputLayer1",
+ layerType: "Input",
+ inputSlots:
+ [{
+ index: 0,
+ connection: {sourceLayerIndex:0, outputSlotIndex:0 },
+ }],
+ outputSlots:
+ [{
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + inputShape1 + R"(,
+ dataType: )" + dataType1 + R"(
+ }
+ }]
}
+ }
+ }
+ },
+ {
+ layer_type: "ReverseV2Layer",
+ layer : {
+ base: {
+ index:2,
+ layerName: "ReverseV2Layer",
+ layerType: "ReverseV2",
+ inputSlots:
+ [
+ {
+ index: 0,
+ connection: {sourceLayerIndex:0, outputSlotIndex:0 },
+ },
+ {
+ index: 1,
+ connection: {sourceLayerIndex:1, outputSlotIndex:0 },
+ }
+ ],
+ outputSlots:
+ [{
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + outputShape + R"(,
+ dataType: )" + dataType0 + R"(
+ }
}]
- },
- descriptor: {
- axis: )" + axis + R"(
}
}
},
@@ -76,31 +111,32 @@
layer_type: "OutputLayer",
layer: {
base:{
- layerBindingId: 2,
- base: {
- index: 2,
- layerName: "OutputLayer",
- layerType: "Output",
- inputSlots: [{
- index: 0,
- connection: {sourceLayerIndex:1, outputSlotIndex:0 },
- }],
- outputSlots: [{
- index: 0,
- tensorInfo: {
- dimensions: )" + outputShape + R"(,
- dataType: )" + dataType + R"(
- },
- }],
- }
+ layerBindingId: 0,
+ base: {
+ index: 3,
+ layerName: "OutputLayer",
+ layerType: "Output",
+ inputSlots:
+ [{
+ index: 0,
+ connection: {sourceLayerIndex:2, outputSlotIndex:0 },
+ }],
+ outputSlots:
+ [{
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + outputShape + R"(,
+ dataType: )" + dataType0 + R"(
+ }
+ }]
+ }
}
}
}
]
- }
- )";
+ } )";
- SetupSingleInputSingleOutput("InputLayer", "OutputLayer");
+ Setup();
}
};
@@ -109,65 +145,155 @@
struct SimpleReverseV2FixtureFloat32 : ReverseV2Fixture
{
SimpleReverseV2FixtureFloat32()
- : ReverseV2Fixture("[ 2, 2 ]",
- "[ 2, 2 ]",
- "Float32",
- "[1]")
+ : ReverseV2Fixture("[ 2, 2 ]",
+ "[ 1 ]",
+ "[ 2, 2 ]",
+ "Float32",
+ "Signed32")
{}
};
TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32, "SimpleReverseV2TestFloat32")
{
- RunTest<4, armnn::DataType::Float32>(
+ RunTest<2, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>(
0,
- { 1.0f, 2.0f,
- 3.0f, 4.0f },
- { 2.0f, 1.0f,
- 4.0f, 3.0f }
- );
- }
-
- struct SimpleReverseV2FixtureFloat32ZeroAxis : ReverseV2Fixture
- {
- SimpleReverseV2FixtureFloat32ZeroAxis()
- : ReverseV2Fixture("[ 2, 2 ]",
- "[ 2, 2 ]",
- "Float32",
- "[0]")
- {}
- };
-
- TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32ZeroAxis, "SimpleReverseV2TestFloat32ZeroAxis")
- {
- RunTest<4, armnn::DataType::Float32>(
- 0,
- { 1.0f, 2.0f,
- 3.0f, 4.0f },
- { 3.0f, 4.0f,
- 1.0f, 2.0f }
+ {
+ {
+ "InputLayer0",
+ { 1.0f, 2.0f,
+ 3.0f, 4.0f }
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { 1 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 2.0f, 1.0f,
+ 4.0f, 3.0f }
+ }
+ }
);
}
- struct SimpleReverseV2FixtureFloat32NegativeAxis : ReverseV2Fixture
+ struct SimpleReverseV2FixtureFloat32OtherAxis : ReverseV2Fixture
{
- SimpleReverseV2FixtureFloat32NegativeAxis()
- : ReverseV2Fixture("[ 3, 3 ]",
- "[ 3, 3 ]",
- "Float32",
- "[-1]")
+ SimpleReverseV2FixtureFloat32OtherAxis()
+ : ReverseV2Fixture("[ 2, 2 ]",
+ "[ 1 ]",
+ "[ 2, 2 ]",
+ "Float32",
+ "Signed32")
{}
};
- TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32NegativeAxis, "SimpleReverseV2TestFloat32NegativeAxis")
+ TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32OtherAxis, "SimpleReverseV2FixtureFloat32OtherAxis")
{
- RunTest<4, armnn::DataType::Float32>(
- 0,
- { 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f },
- { 3.0f, 2.0f, 1.0f,
- 6.0f, 5.0f, 4.0f,
- 9.0f, 8.0f, 7.0f }
+ RunTest<2, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>(
+ 0,
+ {
+ {
+ "InputLayer0",
+ { 1.0f, 2.0f,
+ 3.0f, 4.0f }
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { 1 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 2.0f, 1.0f,
+ 4.0f, 3.0f }
+ }
+ }
+ );
+ }
+
+ struct SimpleReverseV2FixtureFloat32NegativeFirstAxis : ReverseV2Fixture
+ {
+ SimpleReverseV2FixtureFloat32NegativeFirstAxis()
+ : ReverseV2Fixture("[ 2, 2 ]",
+ "[ 1 ]",
+ "[ 2, 2 ]",
+ "Float32",
+ "Signed32")
+ {}
+ };
+
+ TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32NegativeFirstAxis, "SimpleReverseV2FixtureFloat32NegativeFirstAxis")
+ {
+ RunTest<2, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>(
+ 0,
+ {
+ {
+ "InputLayer0",
+ { 1.0f, 2.0f,
+ 3.0f, 4.0f }
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { -2 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 3.0f, 4.0f,
+ 1.0f, 2.0f }
+ }
+ }
+ );
+ }
+
+ struct SimpleReverseV2FixtureFloat32NegativeSecondAxis : ReverseV2Fixture
+ {
+ SimpleReverseV2FixtureFloat32NegativeSecondAxis()
+ : ReverseV2Fixture("[ 3, 3 ]",
+ "[ 1 ]",
+ "[ 3, 3 ]",
+ "Float32",
+ "Signed32")
+ {}
+ };
+
+ TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32NegativeSecondAxis,
+ "SimpleReverseV2FixtureFloat32NegativeSecondAxis")
+ {
+ RunTest<2, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>(
+ 0,
+ {
+ {
+ "InputLayer0",
+ { 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f }
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { -1 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 3.0f, 2.0f, 1.0f,
+ 6.0f, 5.0f, 4.0f,
+ 9.0f, 8.0f, 7.0f }
+ }
+ }
);
}
@@ -175,38 +301,55 @@
{
SimpleReverseV2FixtureFloat32ThreeAxis()
: ReverseV2Fixture("[ 3, 3, 3 ]",
+ "[ 3 ]",
"[ 3, 3, 3 ]",
"Float32",
- "[0, 2, 1]")
+ "Signed32")
{}
};
TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32ThreeAxis, "SimpleReverseV2TestFloat32ThreeAxis")
{
- RunTest<4, armnn::DataType::Float32>(
- 0,
- { 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f,
+ RunTest<2, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>(
+ 0,
+ {
+ {
+ "InputLayer0",
+ { 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
- 11.0f, 12.0f, 13.0f,
- 14.0f, 15.0f, 16.0f,
- 17.0f, 18.0f, 19.0f,
+ 11.0f, 12.0f, 13.0f,
+ 14.0f, 15.0f, 16.0f,
+ 17.0f, 18.0f, 19.0f,
- 21.0f, 22.0f, 23.0f,
- 24.0f, 25.0f, 26.0f,
- 27.0f, 28.0f, 29.0f },
- { 29.0f, 28.0f, 27.0f,
- 26.0f, 25.0f, 24.0f,
- 23.0f, 22.0f, 21.0f,
+ 21.0f, 22.0f, 23.0f,
+ 24.0f, 25.0f, 26.0f,
+ 27.0f, 28.0f, 29.0f },
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { 0, 2, 1 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 29.0f, 28.0f, 27.0f,
+ 26.0f, 25.0f, 24.0f,
+ 23.0f, 22.0f, 21.0f,
- 19.0f, 18.0f, 17.0f,
- 16.0f, 15.0f, 14.0f,
- 13.0f, 12.0f, 11.0f,
+ 19.0f, 18.0f, 17.0f,
+ 16.0f, 15.0f, 14.0f,
+ 13.0f, 12.0f, 11.0f,
- 9.0f, 8.0f, 7.0f,
- 6.0f, 5.0f, 4.0f,
- 3.0f, 2.0f, 1.0f }
+ 9.0f, 8.0f, 7.0f,
+ 6.0f, 5.0f, 4.0f,
+ 3.0f, 2.0f, 1.0f }
+ }
+ }
);
}
@@ -214,38 +357,55 @@
{
SimpleReverseV2FixtureQuantisedAsymm8ThreeAxis()
: ReverseV2Fixture("[ 3, 3, 3 ]",
+ "[ 3 ]",
"[ 3, 3, 3 ]",
"QuantisedAsymm8",
- "[0, 2, 1]")
+ "Signed32")
{}
};
TEST_CASE_FIXTURE(SimpleReverseV2FixtureQuantisedAsymm8ThreeAxis, "SimpleReverseV2TestQuantisedAsymm8ThreeAxis")
{
- RunTest<4, armnn::DataType::QAsymmU8>(
- 0,
- { 1, 2, 3,
- 4, 5, 6,
- 7, 8, 9,
+ RunTest<2, armnn::DataType::QAsymmU8, armnn::DataType::Signed32, armnn::DataType::QAsymmU8>(
+ 0,
+ {
+ {
+ "InputLayer0",
+ { 1, 2, 3,
+ 4, 5, 6,
+ 7, 8, 9,
- 11, 12, 13,
- 14, 15, 16,
- 17, 18, 19,
+ 11, 12, 13,
+ 14, 15, 16,
+ 17, 18, 19,
- 21, 22, 23,
- 24, 25, 26,
- 27, 28, 29 },
- { 29, 28, 27,
- 26, 25, 24,
- 23, 22, 21,
+ 21, 22, 23,
+ 24, 25, 26,
+ 27, 28, 29 },
+ }
+ },
+ {
+ {
+ "InputLayer1",
+ { 0, 2, 1 }
+ }
+ },
+ {
+ {
+ "OutputLayer",
+ { 29, 28, 27,
+ 26, 25, 24,
+ 23, 22, 21,
- 19, 18, 17,
- 16, 15, 14,
- 13, 12, 11,
+ 19, 18, 17,
+ 16, 15, 14,
+ 13, 12, 11,
- 9, 8, 7,
- 6, 5, 4,
- 3, 2, 1 }
+ 9, 8, 7,
+ 6, 5, 4,
+ 3, 2, 1 }
+ }
+ }
);
}
}
diff --git a/src/armnnDeserializer/test/ParserFlatbuffersSerializeFixture.hpp b/src/armnnDeserializer/test/ParserFlatbuffersSerializeFixture.hpp
index 31ff026..0b717bc 100644
--- a/src/armnnDeserializer/test/ParserFlatbuffersSerializeFixture.hpp
+++ b/src/armnnDeserializer/test/ParserFlatbuffersSerializeFixture.hpp
@@ -1,5 +1,5 @@
//
-// Copyright © 2017 Arm Ltd. All rights reserved.
+// Copyright © 2019-2023 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
@@ -150,6 +150,18 @@
const std::map<std::string, std::vector<InputDataType>>& inputData,
const std::map<std::string, std::vector<OutputDataType>>& expectedOutputData);
+ template<std::size_t NumOutputDimensions,
+ armnn::DataType ArmnnInputType0,
+ armnn::DataType ArmnnInputType1,
+ armnn::DataType ArmnnOutputType,
+ typename InputDataType0 = armnn::ResolveType<ArmnnInputType0>,
+ typename InputDataType1 = armnn::ResolveType<ArmnnInputType1>,
+ typename OutputDataType = armnn::ResolveType<ArmnnOutputType>>
+ void RunTest(unsigned int layersId,
+ const std::map<std::string, std::vector<InputDataType0>>& inputData0,
+ const std::map<std::string, std::vector<InputDataType1>>& inputData1,
+ const std::map<std::string, std::vector<OutputDataType>>& expectedOutputData);
+
void CheckTensors(const TensorRawPtr& tensors, size_t shapeSize, const std::vector<int32_t>& shape,
armnnSerializer::TensorInfo tensorType, const std::string& name,
const float scale, const int64_t zeroPoint)
@@ -246,3 +258,68 @@
CHECK_MESSAGE(result.m_Result, result.m_Message.str());
}
}
+
+template<std::size_t NumOutputDimensions,
+ armnn::DataType ArmnnInputType0,
+ armnn::DataType ArmnnInputType1,
+ armnn::DataType ArmnnOutputType,
+ typename InputDataType0,
+ typename InputDataType1,
+ typename OutputDataType>
+void ParserFlatbuffersSerializeFixture::RunTest(
+ unsigned int layersId,
+ const std::map<std::string, std::vector<InputDataType0>>& inputData0,
+ const std::map<std::string, std::vector<InputDataType1>>& inputData1,
+ const std::map<std::string, std::vector<OutputDataType>>& expectedOutputData)
+{
+ auto ConvertBindingInfo = [](const armnnDeserializer::BindingPointInfo& bindingInfo)
+ {
+ return std::make_pair(bindingInfo.m_BindingId, bindingInfo.m_TensorInfo);
+ };
+
+ // Setup the armnn input tensors from the given vectors.
+ armnn::InputTensors inputTensors;
+ for (auto&& it : inputData0)
+ {
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkInputBindingInfo(layersId, it.first));
+ bindingInfo.second.SetConstant(true);
+ armnn::VerifyTensorInfoDataType(bindingInfo.second, ArmnnInputType0);
+ inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
+ }
+
+ for (auto&& it : inputData1)
+ {
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkInputBindingInfo(layersId, it.first));
+ bindingInfo.second.SetConstant(true);
+ armnn::VerifyTensorInfoDataType(bindingInfo.second, ArmnnInputType1);
+ inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
+ }
+
+ // Allocate storage for the output tensors to be written to and setup the armnn output tensors.
+ std::map<std::string, std::vector<OutputDataType>> outputStorage;
+ armnn::OutputTensors outputTensors;
+ for (auto&& it : expectedOutputData)
+ {
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
+ armnn::VerifyTensorInfoDataType(bindingInfo.second, ArmnnOutputType);
+ outputStorage.emplace(it.first, std::vector<OutputDataType>(bindingInfo.second.GetNumElements()));
+ outputTensors.push_back(
+ { bindingInfo.first, armnn::Tensor(bindingInfo.second, outputStorage.at(it.first).data()) });
+ }
+
+ m_Runtime->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);
+
+ // Compare each output tensor to the expected values
+ for (auto&& it : expectedOutputData)
+ {
+ armnn::BindingPointInfo bindingInfo = ConvertBindingInfo(
+ m_Parser->GetNetworkOutputBindingInfo(layersId, it.first));
+ auto outputExpected = it.second;
+ auto result = CompareTensors(outputExpected, outputStorage[it.first],
+ bindingInfo.second.GetShape(), bindingInfo.second.GetShape());
+ CHECK_MESSAGE(result.m_Result, result.m_Message.str());
+ }
+}
diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs
index 995a601..75dd252 100644
--- a/src/armnnSerializer/ArmnnSchema.fbs
+++ b/src/armnnSerializer/ArmnnSchema.fbs
@@ -984,11 +984,6 @@
table ReverseV2Layer {
base:LayerBase;
- descriptor:ReverseV2Descriptor;
-}
-
-table ReverseV2Descriptor {
- axis:[int];
}
table StackLayer {
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index e10b66f..39a4295 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -1036,20 +1036,14 @@
}
void SerializerStrategy::SerializeReverseV2Layer(const armnn::IConnectableLayer* layer,
- const armnn::ReverseV2Descriptor& reverseV2Descriptor,
- const char* name)
+ const char* name)
{
IgnoreUnused(name);
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ReverseV2);
- auto flatBufferDescriptor =
- CreateReverseV2Descriptor(m_flatBufferBuilder,
- m_flatBufferBuilder.CreateVector(reverseV2Descriptor.m_Axis));
-
auto flatBufferLayer = serializer::CreateReverseV2Layer(m_flatBufferBuilder,
- flatBufferBaseLayer,
- flatBufferDescriptor);
+ flatBufferBaseLayer);
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ReverseV2Layer);
}
@@ -2357,9 +2351,7 @@
}
case armnn::LayerType::ReverseV2:
{
- const armnn::ReverseV2Descriptor& layerDescriptor =
- static_cast<const armnn::ReverseV2Descriptor&>(descriptor);
- SerializeReverseV2Layer(layer, layerDescriptor, name);
+ SerializeReverseV2Layer(layer, name);
break;
}
case armnn::LayerType::Shape:
diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp
index eb72475..9e9eca8 100644
--- a/src/armnnSerializer/Serializer.hpp
+++ b/src/armnnSerializer/Serializer.hpp
@@ -290,7 +290,6 @@
const char* name = nullptr);
void SerializeReverseV2Layer(const armnn::IConnectableLayer* layer,
- const armnn::ReverseV2Descriptor& reverseV2Descriptor,
const char* name = nullptr);
void SerializeSliceLayer(const armnn::IConnectableLayer* layer,
diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp
index 49971d2..163e5c8 100644
--- a/src/armnnSerializer/test/SerializerTests.cpp
+++ b/src/armnnSerializer/test/SerializerTests.cpp
@@ -2457,26 +2457,27 @@
{
const std::string layerName("reverseV2");
const armnn::TensorInfo inputInfo = armnn::TensorInfo({2, 3, 4}, armnn::DataType::Float32);
+ const armnn::TensorInfo axisInfo = armnn::TensorInfo({3}, armnn::DataType::Signed32, 0.0f, 0, true);
const armnn::TensorInfo outputInfo = armnn::TensorInfo({2, 3, 4}, armnn::DataType::Float32);
- armnn::ReverseV2Descriptor desc;
- desc.m_Axis = {1, 0, 2};
-
armnn::INetworkPtr network = armnn::INetwork::Create();
armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
- armnn::IConnectableLayer* const reverseV2Layer = network->AddReverseV2Layer(desc, layerName.c_str());
+ armnn::IConnectableLayer* const axisLayer = network->AddInputLayer(1);
+ armnn::IConnectableLayer* const reverseV2Layer = network->AddReverseV2Layer(layerName.c_str());
armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
inputLayer->GetOutputSlot(0).Connect(reverseV2Layer->GetInputSlot(0));
+ axisLayer->GetOutputSlot(0).Connect(reverseV2Layer->GetInputSlot(1));
reverseV2Layer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
+ axisLayer->GetOutputSlot(0).SetTensorInfo(axisInfo);
reverseV2Layer->GetOutputSlot(0).SetTensorInfo(outputInfo);
armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
CHECK(deserializedNetwork);
- LayerVerifierBaseWithDescriptor<armnn::ReverseV2Descriptor> verifier(layerName, {inputInfo}, {outputInfo}, desc);
+ LayerVerifierBase verifier(layerName, {inputInfo, axisInfo}, {outputInfo});
deserializedNetwork->ExecuteStrategy(verifier);
}
diff --git a/src/armnnTfLiteParser/TfLiteParser.cpp b/src/armnnTfLiteParser/TfLiteParser.cpp
index 078786c..77ce565 100644
--- a/src/armnnTfLiteParser/TfLiteParser.cpp
+++ b/src/armnnTfLiteParser/TfLiteParser.cpp
@@ -3294,46 +3294,13 @@
TensorInfo axisTensorInfo = ToTensorInfo(inputs[1]);
TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
- std::vector<int32_t> axisTensorData(axisTensorInfo.GetNumElements());
-
- BufferRawPtr axisBufferPtr = GetBuffer(m_Model, inputs[1]->buffer);
- ::memcpy(axisTensorData.data(), axisBufferPtr->data.data(), axisTensorInfo.GetNumBytes());
-
- ReverseV2Descriptor descriptor(axisTensorData);
-
- auto inputRank = static_cast<int32_t>(inputTensorInfo.GetNumDimensions());
- std::vector<bool> dimFlag(inputRank, false);
-
- for (auto axis : axisTensorData)
- {
- if (axis < -inputRank || axis >= inputRank)
- {
- throw ParseException(
- fmt::format("Operation has invalid axis: {} It is out of bounds [ -{}, {} ) {}",
- axis,
- inputRank, inputRank,
- CHECK_LOCATION().AsString()));
- }
-
- auto posAxis = axis < 0 ? axis + inputRank : axis;
-
- if (dimFlag[posAxis])
- {
- throw ParseException(
- fmt::format("Operation has repeated axis: {} {}",
- axis,
- CHECK_LOCATION().AsString()));
- }
- dimFlag[posAxis] = true;
- }
-
- IConnectableLayer* layer = m_Network->AddReverseV2Layer(descriptor, layerName.c_str());
+ IConnectableLayer* layer = m_Network->AddReverseV2Layer(layerName.c_str());
ARMNN_ASSERT(layer != nullptr);
layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
auto inputTensorIndexes = AsUnsignedVector(GetInputTensorIds(m_Model, subgraphIndex, operatorIndex));
- RegisterInputSlots(subgraphIndex, operatorIndex, layer, {inputTensorIndexes[0]});
+ RegisterInputSlots(subgraphIndex, operatorIndex, layer, {inputTensorIndexes[0], inputTensorIndexes[1]});
auto outputTensorIndexes = AsUnsignedVector(GetOutputTensorIds(m_Model, subgraphIndex, operatorIndex));
RegisterOutputSlots(subgraphIndex, operatorIndex, layer, {outputTensorIndexes[0]});
diff --git a/src/armnnTfLiteParser/test/ReverseV2.cpp b/src/armnnTfLiteParser/test/ReverseV2.cpp
index 9604a3a..7dad19a 100644
--- a/src/armnnTfLiteParser/test/ReverseV2.cpp
+++ b/src/armnnTfLiteParser/test/ReverseV2.cpp
@@ -12,7 +12,6 @@
explicit ReverseV2Fixture(const std::string& inputShape,
const std::string& outputShape,
const std::string& axisShape,
- const std::string& axisData,
const std::string& dataType = "FLOAT32",
const std::string& scale = "1.0",
const std::string& offset = "0")
@@ -75,8 +74,8 @@
} ],
"buffers" : [
{ },
- { "data": )" + axisData + R"(, },
{ },
+ { }
]
}
)";
@@ -86,15 +85,30 @@
struct SimpleReverseV2Fixture : public ReverseV2Fixture
{
- SimpleReverseV2Fixture() : ReverseV2Fixture("[ 2, 2, 2 ]", "[ 2, 2, 2 ]", "[ 2 ]", "[ 0,0,0,0, 1,0,0,0 ]") {}
+ SimpleReverseV2Fixture() : ReverseV2Fixture("[ 2, 2, 2 ]", "[ 2, 2, 2 ]", "[ 2 ]" ) {}
};
TEST_CASE_FIXTURE(SimpleReverseV2Fixture, "ParseReverseV2")
{
- RunTest<3, armnn::DataType::Float32>
+ RunTest<3, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>
(0,
{{ "inputTensor", { 1, 2, 3, 4, 5, 6, 7, 8 }}},
+ {{ "axis", { 0, 1 }}},
{{ "outputTensor", { 7, 8, 5, 6, 3, 4, 1, 2 }}});
}
-}
\ No newline at end of file
+struct SimpleReverseV2FixtureNegativeAxis : public ReverseV2Fixture
+{
+ SimpleReverseV2FixtureNegativeAxis() : ReverseV2Fixture("[ 2, 2, 2 ]", "[ 2, 2, 2 ]", "[ 1 ]" ) {}
+};
+
+TEST_CASE_FIXTURE(SimpleReverseV2FixtureNegativeAxis, "ParseReverseV2")
+{
+ RunTest<3, armnn::DataType::Float32, armnn::DataType::Signed32, armnn::DataType::Float32>
+ (0,
+ {{ "inputTensor", { 1, 2, 3, 4, 5, 6, 7, 8 }}},
+ {{ "axis", { -1 }}},
+ {{ "outputTensor", { 2, 1, 4, 3, 6, 5, 8, 7 }}});
+}
+
+}
diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp
index a26aaf4..bd3c7c2 100644
--- a/src/backends/backendsCommon/WorkloadData.cpp
+++ b/src/backends/backendsCommon/WorkloadData.cpp
@@ -1617,18 +1617,35 @@
void ReverseV2QueueDescriptor::Validate(const WorkloadInfo &workloadInfo) const {
const std::string descriptorName{"ReverseV2QueueDescriptor"};
- ValidateNumInputs(workloadInfo, descriptorName, 1);
+ // Backend restriction
+ const unsigned int maxDimensions = 4;
+
+ ValidateNumInputs(workloadInfo, descriptorName, 2);
ValidateNumOutputs(workloadInfo, descriptorName, 1);
const TensorInfo& inputTensorInfo = workloadInfo.m_InputTensorInfos[0];
+ const TensorInfo& axisTensorInfo = workloadInfo.m_InputTensorInfos[1];
const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
- auto inputTensorNumDimensions = inputTensorInfo.GetNumDimensions();
- if (inputTensorNumDimensions > m_Parameters.m_MaxDimension)
+ const auto inputTensorNumDimensions = inputTensorInfo.GetNumDimensions();
+ if (inputTensorNumDimensions > maxDimensions)
{
throw InvalidArgumentException(descriptorName +
": Input tensors with rank greater than " +
- std::to_string(m_Parameters.m_MaxDimension) + " are not supported.");
+ std::to_string(maxDimensions) + " are not supported.");
+ }
+
+ const auto axisTensorNumDimensions = axisTensorInfo.GetNumDimensions();
+ if (axisTensorNumDimensions > maxDimensions)
+ {
+ throw InvalidArgumentException(descriptorName +
+ ": More than " + std::to_string(maxDimensions) + " axes cannot be specified.");
+ }
+
+ if (axisTensorNumDimensions > inputTensorNumDimensions)
+ {
+ throw InvalidArgumentException(descriptorName +
+ ": More axes specified than the number of axes on the input tensor.");
}
std::vector<DataType> supportedTypes =
@@ -1642,44 +1659,18 @@
};
ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
+
+ std::vector<DataType> axisSupportedTypes =
+ {
+ DataType::Signed32,
+ };
+
+ ValidateDataTypes(axisTensorInfo, axisSupportedTypes, descriptorName);
+
ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
-
- if (m_Parameters.m_Axis.size() > inputTensorNumDimensions)
- {
- throw InvalidArgumentException(descriptorName + ": More axes specified than is on the input tensor.");
- }
- if (m_Parameters.m_Axis.size() > m_Parameters.m_MaxDimension)
- {
- throw InvalidArgumentException(descriptorName +
- ": More than " + std::to_string(m_Parameters.m_MaxDimension) + " axes cannot be specified.");
- }
-
- if (! m_Parameters.m_Axis.empty())
- {
- // First check that we have unique axis values
- auto checkAxis = m_Parameters.m_Axis;
- std::sort(checkAxis.begin(), checkAxis.end());
- auto lastUnique = std::unique(checkAxis.begin(), checkAxis.end());
- if (lastUnique != checkAxis.end())
- {
- throw InvalidArgumentException(descriptorName + ": Axes values must be unique.");
- }
-
- // Next check that the axes values are in range: [-rank, rank]
- const auto minmax =
- std::minmax_element(std::begin(m_Parameters.m_Axis), std::end(m_Parameters.m_Axis));
- if (((*minmax.first) < int32_t(-inputTensorNumDimensions)) ||
- ((*minmax.second) >= int32_t (inputTensorNumDimensions)))
- {
- throw InvalidArgumentException(descriptorName +
- ": Axes values must in range [-" + std::to_string(inputTensorNumDimensions) + "," +
- std::to_string(inputTensorNumDimensions) + "].");
- }
- }
}
-
void FakeQuantizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
const std::string descriptorName{"FakeQuantizationQueueDescriptor"};
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index ac4bcc9..ee797b6 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -1121,12 +1121,12 @@
}
case LayerType::ReverseV2:
{
- auto cLayer = PolymorphicDowncast<const ReverseV2Layer*>(&layer);
- const TensorInfo& input = layer.GetInputSlot(0).GetTensorInfo();
+ const TensorInfo& input0 = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+ const TensorInfo& input1 = layer.GetInputSlot(1).GetConnection()->GetTensorInfo();
const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
- result = layerSupportObject.IsReverseV2Supported(OverrideDataType(input, dataType),
+ result = layerSupportObject.IsReverseV2Supported(OverrideDataType(input0, dataType),
+ OverrideDataType(input1, armnn::DataType::Signed32),
OverrideDataType(output, dataType),
- cLayer->GetParameters(),
reason);
break;
}
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index f7a852f..182fab9 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -744,8 +744,6 @@
DECLARE_LAYER_POLICY_2_PARAM(Reshape)
-DECLARE_LAYER_POLICY_2_PARAM(ReverseV2)
-
DECLARE_LAYER_POLICY_1_PARAM(Shape)
DECLARE_LAYER_POLICY_2_PARAM(Slice)
diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
index 586b831..3cfd614 100644
--- a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
@@ -23,23 +23,25 @@
armnn::IWorkloadFactory& workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory,
- armnn::ReverseV2Descriptor descriptor,
const std::vector<T>& input,
+ const std::vector<int>& axis,
const std::vector<T>& outputExpected,
const armnn::TensorInfo& inputInfo,
+ const armnn::TensorInfo& axisInfo,
const armnn::TensorInfo& outputInfo)
{
LayerTestResult<T, NumDims> result(outputInfo);
std::vector<T> outputActual(outputInfo.GetNumElements());
std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
+ std::unique_ptr<armnn::ITensorHandle> axisHandle = tensorHandleFactory.CreateTensorHandle(axisInfo);
std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
armnn::ReverseV2QueueDescriptor queueDescriptor;
- queueDescriptor.m_Parameters = std::move(descriptor);
armnn::WorkloadInfo workloadInfo;
AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
+ AddInputToWorkload(queueDescriptor, workloadInfo, axisInfo, axisHandle.get());
AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
// Don't execute if ReverseV2 is not supported, as an exception will be raised.
@@ -47,9 +49,9 @@
std::string reasonIfUnsupported;
armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend);
result.m_Supported = handle.IsReverseV2Supported(inputInfo,
- outputInfo,
- queueDescriptor.m_Parameters,
- reasonIfUnsupported);
+ axisInfo,
+ outputInfo,
+ reasonIfUnsupported);
if (!result.m_Supported)
{
return result;
@@ -58,9 +60,11 @@
auto workload = workloadFactory.CreateWorkload(armnn::LayerType::ReverseV2, queueDescriptor, workloadInfo);
inputHandle->Allocate();
+ axisHandle->Allocate();
outputHandle->Allocate();
CopyDataToITensorHandle(inputHandle.get(), input.data());
+ CopyDataToITensorHandle(axisHandle.get(), axis.data());
workload->PostAllocationConfigure();
ExecuteWorkload(*workload, memoryManager);
@@ -80,13 +84,13 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is the same as input
- auto descriptor = armnn::ReverseV2Descriptor();
+ // Simple test with no axes set so output is the same as input
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -94,6 +98,8 @@
3, 4
}, qScale, qOffset);
+ std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset);
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
1, 2,
3, 4
@@ -102,10 +108,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -115,26 +122,27 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. Empty tensor set so output is the same as input
- auto descriptor = armnn::ReverseV2Descriptor();
+ // Simple test with empty input tensor
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({0}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({0}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({0}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
-
+ std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset);
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -144,12 +152,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -157,6 +164,8 @@
3, 4
}, qScale, qOffset);
+ std::vector<int> axis = {0};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3,
2, 1
@@ -165,10 +174,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -178,12 +188,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -191,6 +200,8 @@
3, 4
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
2, 1,
4, 3
@@ -199,10 +210,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -212,12 +224,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -225,6 +236,8 @@
3, 4
}, qScale, qOffset);
+ std::vector<int> axis = {1,0};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3,
2, 1
@@ -233,10 +246,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -246,12 +260,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -263,6 +276,8 @@
21, 22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
9, 10, 11, 12,
5, 6, 7, 8,
@@ -275,10 +290,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -288,12 +304,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -305,6 +320,8 @@
21, 22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {0, 1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
21, 22, 23, 24,
17, 18, 19, 20,
@@ -317,10 +334,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -330,14 +348,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0, 2});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -349,6 +364,8 @@
21, 22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {1, 0, 2};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
24, 23, 22, 21,
20, 19, 18, 17,
@@ -361,10 +378,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -374,14 +392,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -395,6 +410,8 @@
22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {0};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
13, 14, 15,
16, 17, 18,
@@ -409,10 +426,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -422,14 +440,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -443,6 +458,8 @@
22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {0, 1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
19, 20, 21,
22, 23, 24,
@@ -457,10 +474,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -470,14 +488,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -491,6 +506,8 @@
22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {0, 1, 2};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
22, 23, 24,
19, 20, 21,
@@ -505,10 +522,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -518,14 +536,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2, 3});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({4}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -539,24 +554,27 @@
22, 23, 24
}, qScale, qOffset);
+ std::vector<int> axis = {0, 1, 2, 3};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
- 24, 23, 22,
- 21, 20, 19,
- 18, 17, 16,
- 15, 14, 13,
- 12, 11, 10,
- 9, 8, 7,
- 6, 5, 4,
- 3, 2, 1
- }, qScale, qOffset);
+ 24, 23, 22,
+ 21, 20, 19,
+ 18, 17, 16,
+ 15, 14, 13,
+ 12, 11, 10,
+ 9, 8, 7,
+ 6, 5, 4,
+ 3, 2, 1
+ }, qScale, qOffset);
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -566,13 +584,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -580,6 +596,8 @@
4, 5, 6
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
3, 2, 1,
6, 5, 4
@@ -588,10 +606,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -601,14 +620,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -616,6 +632,8 @@
4, 5, 6
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
3, 2, 1,
6, 5, 4
@@ -624,10 +642,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -637,14 +656,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -652,6 +668,8 @@
5, 6, 7, 8
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5
@@ -660,10 +678,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -673,14 +692,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -688,6 +704,8 @@
5, 6, 7, 8
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5
@@ -696,10 +714,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -709,14 +728,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({3, 3}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({3, 3}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -725,6 +741,8 @@
7, 8, 9
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
3, 2, 1,
6, 5, 4,
@@ -734,10 +752,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -747,14 +766,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -763,6 +779,8 @@
7, 8, 9
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
3, 2, 1,
6, 5, 4,
@@ -772,10 +790,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -785,14 +804,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({3, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({3, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -801,6 +817,8 @@
9, 10, 11, 12
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5,
@@ -810,10 +828,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -823,14 +842,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -839,6 +855,8 @@
9, 10, 11, 12
}, qScale, qOffset);
+ std::vector<int> axis = {1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5,
@@ -848,10 +866,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -861,14 +880,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {-1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -876,6 +892,8 @@
5, 6, 7, 8,
}, qScale, qOffset);
+ std::vector<int> axis = {-1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5
@@ -884,10 +902,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -897,14 +916,11 @@
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
const armnn::ITensorHandleFactory& tensorHandleFactory)
{
- // Simple test with default descriptor. No axes set so output is
- // the same as input
- auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, -1});
-
float qScale = 1.0f;
int32_t qOffset = 0;
armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+ armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -912,6 +928,8 @@
5, 6, 7, 8,
}, qScale, qOffset);
+ std::vector<int> axis = {1, -1};
+
std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
4, 3, 2, 1,
8, 7, 6, 5
@@ -920,10 +938,11 @@
return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
memoryManager,
tensorHandleFactory,
- descriptor,
input,
+ axis,
outputExpected,
inputInfo,
+ axisInfo,
outputInfo);
}
@@ -1081,4 +1100,4 @@
ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QSymmS16>(
armnn::IWorkloadFactory& workloadFactory,
const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
- const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file
+ const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index 1d5fab1..e94478f 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -344,7 +344,7 @@
case LayerType::ReverseV2:
return IsReverseV2Supported(infos[0],
infos[1],
- *(PolymorphicDowncast<const ReverseV2Descriptor*>(&descriptor)),
+ infos[2],
reasonIfUnsupported);
case LayerType::Reduce:
return IsReduceSupported(infos[0],
@@ -2361,12 +2361,11 @@
return supported;
}
-bool RefLayerSupport::IsReverseV2Supported(const TensorInfo& input,
+bool RefLayerSupport::IsReverseV2Supported(const TensorInfo& input0,
+ const TensorInfo& input1,
const TensorInfo& output,
- const ReverseV2Descriptor& descriptor,
Optional<std::string&> reasonIfUnsupported) const
{
- IgnoreUnused(descriptor);
bool supported = true;
// ReverseV2 is data type agnostic so it can support all the types in the Reference backend
std::array<DataType,6> supportedTypes =
@@ -2379,14 +2378,22 @@
DataType::QSymmS16
};
- supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
- "Reference ReverseV2: input type not supported");
+ supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+ "Reference ReverseV2: input0 type not supported");
supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
"Reference ReverseV2: output type not supported");
- supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
- "Reference ReverseV2: input and output types not matching");
+ supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+ "Reference ReverseV2: input0 and output types not matching");
+
+ std::array<DataType,6> input2SupportedTypes =
+ {
+ DataType::Signed32
+ };
+
+ supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
+ "Reference ReverseV2: input1 type not supported");
return supported;
}
diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp
index 0afb9c2..21d59e2 100644
--- a/src/backends/reference/RefLayerSupport.hpp
+++ b/src/backends/reference/RefLayerSupport.hpp
@@ -299,9 +299,9 @@
const ResizeDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
- bool IsReverseV2Supported(const TensorInfo& input,
+ bool IsReverseV2Supported(const TensorInfo& input0,
+ const TensorInfo& input1,
const TensorInfo& output,
- const ReverseV2Descriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
bool IsShapeSupported(const TensorInfo& input,
diff --git a/src/backends/reference/workloads/RefReverseV2Workload.cpp b/src/backends/reference/workloads/RefReverseV2Workload.cpp
index cd2d9f9..22d5449 100644
--- a/src/backends/reference/workloads/RefReverseV2Workload.cpp
+++ b/src/backends/reference/workloads/RefReverseV2Workload.cpp
@@ -32,16 +32,21 @@
ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefReverseV2Workload_Execute");
const TensorInfo& inputInfo = GetTensorInfo(inputs[0]);
+ const TensorInfo& axisInfo = GetTensorInfo(inputs[1]);
std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(inputs[0]),
inputs[0]->Map());
+ std::unique_ptr<Decoder<int>> axisDecoder = MakeDecoder<int>(GetTensorInfo(inputs[1]),
+ inputs[1]->Map());
+
std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(outputs[0]),
outputs[0]->Map());
- ReverseV2(m_Data.m_Parameters,
- inputInfo,
+ ReverseV2(inputInfo,
+ axisInfo,
*inputDecoder,
+ *axisDecoder,
*outputEncoder);
}
diff --git a/src/backends/reference/workloads/ReverseV2Impl.cpp b/src/backends/reference/workloads/ReverseV2Impl.cpp
index f6d5fd7..896f905 100644
--- a/src/backends/reference/workloads/ReverseV2Impl.cpp
+++ b/src/backends/reference/workloads/ReverseV2Impl.cpp
@@ -75,13 +75,16 @@
return outputIdx;
}
-void ReverseV2(const ReverseV2Descriptor& params,
- const TensorInfo& inputInfo,
+void ReverseV2(const TensorInfo& inputInfo,
+ const TensorInfo& axisInfo,
Decoder<float>& inputDecoder,
+ Decoder<int>& axisDecoder,
Encoder<float>& outputEncoder)
{
+ unsigned int axesRank = static_cast<unsigned int>(axisInfo.GetNumElements());
+
// Empty axis and empty tensor case: copy input to output
- if (params.m_Axis.empty() || inputInfo.GetNumElements() == 0)
+ if ((axesRank == 0) || inputInfo.GetNumElements() == 0)
{
for (unsigned idx = 0; idx < inputInfo.GetNumElements(); idx++)
{
@@ -95,11 +98,19 @@
unsigned int inputRank = static_cast<unsigned int>(inputInfo.GetNumDimensions());
- std::vector<bool>axisFlag(inputRank, false);
- std::vector<unsigned int>dimSize(inputRank, 0);
+ std::vector<bool> axisFlag(inputRank, false);
+ std::vector<unsigned int> dimSize(inputRank, 0);
+ std::vector<int32_t> axis(axesRank, 0);
+
+ // Decode the axis information
+ for (unsigned int i=0; i < axesRank; i++)
+ {
+ axis[i] = axisDecoder.Get();
+ axisDecoder += 1;
+ }
// Make sure the axes are positive
- for (int32_t axisElement: params.m_Axis)
+ for (int32_t axisElement: axis)
{
axisElement = axisElement < 0 ? axisElement + static_cast<int32_t>(inputRank) : axisElement;
axisFlag[static_cast<uint32_t>(axisElement)] = true;
diff --git a/src/backends/reference/workloads/ReverseV2Impl.hpp b/src/backends/reference/workloads/ReverseV2Impl.hpp
index bc1fe1d..59407d4 100644
--- a/src/backends/reference/workloads/ReverseV2Impl.hpp
+++ b/src/backends/reference/workloads/ReverseV2Impl.hpp
@@ -13,9 +13,10 @@
namespace armnn
{
-void ReverseV2(const ReverseV2Descriptor& params,
- const TensorInfo& inputInfo,
+void ReverseV2(const TensorInfo& inputInfo,
+ const TensorInfo& axisInfo,
Decoder<float>& inputDecoder,
+ Decoder<int>& axisDecoder,
Encoder<float>& outputEncoder);
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn