From 944fb508b1c30415e423b8916849c66a13867ea4 Mon Sep 17 00:00:00 2001 From: Tracy Narine Date: Tue, 4 Jul 2023 15:08:57 +0100 Subject: IVGCVSW-7832 Add REVERSE_V2 to Serializer and Deserializer * Support for ReverseV2 for the serializer and deserializer added * Tests added * CMake files updated for the build * Fixed an issue with the operator_list documentation for Resize and ReverseV2 Signed-off-by: Tracy Narine Change-Id: If396f55ecdd763d6f91c51707809f4bd58715cec --- src/armnnDeserializer/Deserializer.cpp | 29 +++ src/armnnDeserializer/Deserializer.hpp | 3 +- .../test/DeserializeReverseV2.cpp | 251 +++++++++++++++++++++ 3 files changed, 282 insertions(+), 1 deletion(-) create mode 100644 src/armnnDeserializer/test/DeserializeReverseV2.cpp (limited to 'src/armnnDeserializer') diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp index 79cc3987d5..e940bd69ec 100644 --- a/src/armnnDeserializer/Deserializer.cpp +++ b/src/armnnDeserializer/Deserializer.cpp @@ -263,6 +263,7 @@ m_ParserFunctions(Layer_MAX+1, &IDeserializer::DeserializerImpl::ParseUnsupporte m_ParserFunctions[Layer_ReshapeLayer] = &DeserializerImpl::ParseReshape; m_ParserFunctions[Layer_ResizeBilinearLayer] = &DeserializerImpl::ParseResizeBilinear; m_ParserFunctions[Layer_ResizeLayer] = &DeserializerImpl::ParseResize; + m_ParserFunctions[Layer_ReverseV2Layer] = &DeserializerImpl::ParseReverseV2; m_ParserFunctions[Layer_RsqrtLayer] = &DeserializerImpl::ParseRsqrt; m_ParserFunctions[Layer_ShapeLayer] = &DeserializerImpl::ParseShape; m_ParserFunctions[Layer_SliceLayer] = &DeserializerImpl::ParseSlice; @@ -396,6 +397,8 @@ LayerBaseRawPtr IDeserializer::DeserializerImpl::GetBaseLayer(const GraphPtr& gr return graphPtr->layers()->Get(layerIndex)->layer_as_ResizeBilinearLayer()->base(); case Layer::Layer_ResizeLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_ResizeLayer()->base(); + case Layer::Layer_ReverseV2Layer: + return graphPtr->layers()->Get(layerIndex)->layer_as_ReverseV2Layer()->base(); case Layer::Layer_RsqrtLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_RsqrtLayer()->base(); case Layer::Layer_ShapeLayer: @@ -2734,6 +2737,32 @@ void IDeserializer::DeserializerImpl::ParseResize(GraphPtr graph, unsigned int l RegisterOutputSlots(graph, layerIndex, layer); } +void IDeserializer::DeserializerImpl::ParseReverseV2(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 flatBufferDescriptor = graph->layers()->Get(layerIndex)->layer_as_ReverseV2Layer()->descriptor(); + auto flatBufferAxis = flatBufferDescriptor->axis(); + + armnn::ReverseV2Descriptor descriptor; + descriptor.m_Axis = + std::vector(flatBufferAxis->begin(), flatBufferAxis->end()); + + auto layerName = GetLayerName(graph, layerIndex); + IConnectableLayer* layer = m_Network->AddReverseV2Layer(descriptor, layerName.c_str()); + + armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]); + layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + RegisterInputSlots(graph, layerIndex, layer); + RegisterOutputSlots(graph, layerIndex, layer); +} /// @Note The ResizeBiliniar operation was deprecated and removed in favor of the Resize operation. /// This function is kept for backwards compatibility. diff --git a/src/armnnDeserializer/Deserializer.hpp b/src/armnnDeserializer/Deserializer.hpp index b75c68db0c..b4b93e6fe1 100644 --- a/src/armnnDeserializer/Deserializer.hpp +++ b/src/armnnDeserializer/Deserializer.hpp @@ -136,6 +136,7 @@ private: void ParseReshape(GraphPtr graph, unsigned int layerIndex); void ParseResize(GraphPtr graph, unsigned int layerIndex); void ParseResizeBilinear(GraphPtr graph, unsigned int layerIndex); + void ParseReverseV2(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); @@ -212,4 +213,4 @@ private: std::unordered_map m_GraphConnections; }; -} // namespace armnnDeserializer \ No newline at end of file +} // namespace armnnDeserializer diff --git a/src/armnnDeserializer/test/DeserializeReverseV2.cpp b/src/armnnDeserializer/test/DeserializeReverseV2.cpp new file mode 100644 index 0000000000..73816f8588 --- /dev/null +++ b/src/armnnDeserializer/test/DeserializeReverseV2.cpp @@ -0,0 +1,251 @@ +// +// Copyright © 2023 Arm Ltd and Contributors. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include "ParserFlatbuffersSerializeFixture.hpp" +#include + +#include + +#include + +TEST_SUITE("Deserializer_ReverseV2") +{ + struct ReverseV2Fixture : public ParserFlatbuffersSerializeFixture + { + explicit ReverseV2Fixture(const std::string& inputShape, + const std::string& outputShape, + const std::string& dataType, + const std::string& axis) + { + m_JsonString = R"( + { + inputIds: [0], + outputIds: [2], + layers: [ + { + layer_type: "InputLayer", + layer: { + base: { + layerBindingId: 0, + base: { + index: 0, + layerName: "InputLayer", + layerType: "Input", + inputSlots: [{ + index: 0, + connection: {sourceLayerIndex:0, outputSlotIndex:0 }, + }], + outputSlots: [{ + index: 0, + tensorInfo: { + dimensions: )" + inputShape + R"(, + dataType: )" + dataType + R"( + } + }] + } + } + } + }, + { + layer_type: "ReverseV2Layer", + 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"( + } + }] + }, + descriptor: { + axis: )" + axis + R"( + } + } + }, + { + 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"( + }, + }], + } + } + } + } + ] + } + )"; + + SetupSingleInputSingleOutput("InputLayer", "OutputLayer"); + } + }; + + // Test cases + + struct SimpleReverseV2FixtureFloat32 : ReverseV2Fixture + { + SimpleReverseV2FixtureFloat32() + : ReverseV2Fixture("[ 2, 2 ]", + "[ 2, 2 ]", + "Float32", + "[1]") + {} + }; + + TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32, "SimpleReverseV2TestFloat32") + { + RunTest<4, 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 } + ); + } + + struct SimpleReverseV2FixtureFloat32NegativeAxis : ReverseV2Fixture + { + SimpleReverseV2FixtureFloat32NegativeAxis() + : ReverseV2Fixture("[ 3, 3 ]", + "[ 3, 3 ]", + "Float32", + "[-1]") + {} + }; + + TEST_CASE_FIXTURE(SimpleReverseV2FixtureFloat32NegativeAxis, "SimpleReverseV2TestFloat32NegativeAxis") + { + 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 } + ); + } + + struct SimpleReverseV2FixtureFloat32ThreeAxis : ReverseV2Fixture + { + SimpleReverseV2FixtureFloat32ThreeAxis() + : ReverseV2Fixture("[ 3, 3, 3 ]", + "[ 3, 3, 3 ]", + "Float32", + "[0, 2, 1]") + {} + }; + + 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, + + 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, + + 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 } + ); + } + + struct SimpleReverseV2FixtureQuantisedAsymm8ThreeAxis : ReverseV2Fixture + { + SimpleReverseV2FixtureQuantisedAsymm8ThreeAxis() + : ReverseV2Fixture("[ 3, 3, 3 ]", + "[ 3, 3, 3 ]", + "QuantisedAsymm8", + "[0, 2, 1]") + {} + }; + + TEST_CASE_FIXTURE(SimpleReverseV2FixtureQuantisedAsymm8ThreeAxis, "SimpleReverseV2TestQuantisedAsymm8ThreeAxis") + { + RunTest<4, armnn::DataType::QAsymmU8>( + 0, + { 1, 2, 3, + 4, 5, 6, + 7, 8, 9, + + 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, + + 19, 18, 17, + 16, 15, 14, + 13, 12, 11, + + 9, 8, 7, + 6, 5, 4, + 3, 2, 1 } + ); + } +} -- cgit v1.2.1