From 57728788f65656e4fa08923d12bee0de34a72fc7 Mon Sep 17 00:00:00 2001 From: Nina Drozd Date: Wed, 27 Feb 2019 10:53:27 +0000 Subject: IVGCVSW-2700 Serialize/de-serialize the Normalization layer Change-Id: Ib307ec6c28beb6c158d337678e67a2484c495a06 Signed-off-by: Nina Drozd --- CMakeLists.txt | 1 + src/armnnDeserializer/Deserializer.cpp | 95 ++++++++++++++ src/armnnDeserializer/Deserializer.hpp | 8 +- src/armnnDeserializer/DeserializerSupport.md | 1 + .../test/DeserializeNormalization.cpp | 143 +++++++++++++++++++++ src/armnnSerializer/ArmnnSchema.fbs | 31 ++++- src/armnnSerializer/Serializer.cpp | 23 ++++ src/armnnSerializer/Serializer.hpp | 3 + src/armnnSerializer/SerializerSupport.md | 1 + src/armnnSerializer/SerializerUtils.cpp | 28 ++++ src/armnnSerializer/SerializerUtils.hpp | 6 + src/armnnSerializer/test/SerializerTests.cpp | 49 ++++++- 12 files changed, 384 insertions(+), 5 deletions(-) create mode 100644 src/armnnDeserializer/test/DeserializeNormalization.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a078d73fb7..a21b5f21e8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -604,6 +604,7 @@ if(BUILD_UNIT_TESTS) src/armnnDeserializer/test/DeserializeEqual.cpp src/armnnDeserializer/test/DeserializeFullyConnected.cpp src/armnnDeserializer/test/DeserializeMultiplication.cpp + src/armnnDeserializer/test/DeserializeNormalization.cpp src/armnnDeserializer/test/DeserializePermute.cpp src/armnnDeserializer/test/DeserializePooling2d.cpp src/armnnDeserializer/test/DeserializeReshape.cpp diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp index 076b23e5a4..c7049f6a15 100644 --- a/src/armnnDeserializer/Deserializer.cpp +++ b/src/armnnDeserializer/Deserializer.cpp @@ -197,6 +197,7 @@ m_ParserFunctions(Layer_MAX+1, &Deserializer::ParseUnsupportedLayer) m_ParserFunctions[Layer_MinimumLayer] = &Deserializer::ParseMinimum; m_ParserFunctions[Layer_MaximumLayer] = &Deserializer::ParseMaximum; m_ParserFunctions[Layer_MultiplicationLayer] = &Deserializer::ParseMultiplication; + m_ParserFunctions[Layer_NormalizationLayer] = &Deserializer::ParseNormalization; m_ParserFunctions[Layer_PermuteLayer] = &Deserializer::ParsePermute; m_ParserFunctions[Layer_Pooling2dLayer] = &Deserializer::ParsePooling2d; m_ParserFunctions[Layer_ReshapeLayer] = &Deserializer::ParseReshape; @@ -236,6 +237,8 @@ Deserializer::LayerBaseRawPtr Deserializer::GetBaseLayer(const GraphPtr& graphPt return graphPtr->layers()->Get(layerIndex)->layer_as_MaximumLayer()->base(); case Layer::Layer_MultiplicationLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_MultiplicationLayer()->base(); + case Layer::Layer_NormalizationLayer: + return graphPtr->layers()->Get(layerIndex)->layer_as_NormalizationLayer()->base(); case Layer::Layer_OutputLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_OutputLayer()->base()->base(); case Layer::Layer_PermuteLayer: @@ -1360,4 +1363,96 @@ void Deserializer::ParseSpaceToBatchNd(GraphPtr graph, unsigned int layerIndex) RegisterOutputSlots(graph, layerIndex, layer); } +armnn::NormalizationDescriptor Deserializer::GetNormalizationDescriptor( + Deserializer::NormalizationDescriptorPtr normalizationDescriptor, + unsigned int layerIndex) +{ + armnn::NormalizationDescriptor desc; + + switch (normalizationDescriptor->normChannelType()) + { + case NormalizationAlgorithmChannel_Across: + { + desc.m_NormChannelType = armnn::NormalizationAlgorithmChannel::Across; + break; + } + case NormalizationAlgorithmChannel_Within: + { + desc.m_NormChannelType = armnn::NormalizationAlgorithmChannel::Within; + break; + } + default: + { + BOOST_ASSERT_MSG(false, "Unsupported normalization channel type"); + } + } + + switch (normalizationDescriptor->normMethodType()) + { + case NormalizationAlgorithmMethod_LocalBrightness: + { + desc.m_NormMethodType = armnn::NormalizationAlgorithmMethod::LocalBrightness; + break; + } + case NormalizationAlgorithmMethod_LocalContrast: + { + desc.m_NormMethodType = armnn::NormalizationAlgorithmMethod::LocalContrast; + break; + } + default: + { + BOOST_ASSERT_MSG(false, "Unsupported normalization method type"); + } + } + + switch (normalizationDescriptor->dataLayout()) + { + case DataLayout_NCHW: + { + desc.m_DataLayout = armnn::DataLayout::NCHW; + break; + } + case DataLayout_NHWC: + { + desc.m_DataLayout = armnn::DataLayout::NHWC; + break; + } + default: + { + BOOST_ASSERT_MSG(false, "Unsupported data layout"); + } + } + + desc.m_Alpha = normalizationDescriptor->alpha(); + desc.m_Beta = normalizationDescriptor->beta(); + desc.m_K = normalizationDescriptor->k(); + desc.m_NormSize = normalizationDescriptor->normSize(); + + return desc; +} + +void Deserializer::ParseNormalization(GraphPtr graph, unsigned int layerIndex) +{ + CHECK_LAYERS(graph, 0, layerIndex); + + auto normalizationDes = graph->layers()->Get(layerIndex)->layer_as_NormalizationLayer()->descriptor(); + + Deserializer::TensorRawPtrVector inputs = GetInputs(graph, layerIndex); + CHECK_VALID_SIZE(inputs.size(), 1); + + Deserializer::TensorRawPtrVector outputs = GetOutputs(graph, layerIndex); + CHECK_VALID_SIZE(outputs.size(), 1); + + auto outputInfo = ToTensorInfo(outputs[0]); + + auto normalizationDescriptor = GetNormalizationDescriptor(normalizationDes, layerIndex); + auto layerName = GetLayerName(graph, layerIndex); + + IConnectableLayer* layer = m_Network->AddNormalizationLayer(normalizationDescriptor, layerName.c_str()); + layer->GetOutputSlot(0).SetTensorInfo(outputInfo); + + RegisterInputSlots(graph, layerIndex, layer); + RegisterOutputSlots(graph, layerIndex, layer); +} + } // namespace armnnDeserializer diff --git a/src/armnnDeserializer/Deserializer.hpp b/src/armnnDeserializer/Deserializer.hpp index 1dd7ec5284..fba8b88044 100644 --- a/src/armnnDeserializer/Deserializer.hpp +++ b/src/armnnDeserializer/Deserializer.hpp @@ -19,6 +19,7 @@ public: using GraphPtr = const armnnSerializer::SerializedGraph *; using TensorRawPtr = const armnnSerializer::TensorInfo *; using PoolingDescriptor = const armnnSerializer::Pooling2dDescriptor *; + using NormalizationDescriptorPtr = const armnnSerializer::NormalizationDescriptor *; using TensorRawPtrVector = std::vector; using LayerRawPtr = const armnnSerializer::LayerBase *; using LayerBaseRawPtr = const armnnSerializer::LayerBase *; @@ -51,8 +52,10 @@ public: static LayerBaseRawPtr GetBaseLayer(const GraphPtr& graphPtr, unsigned int layerIndex); static int32_t GetBindingLayerInfo(const GraphPtr& graphPtr, unsigned int layerIndex); static std::string GetLayerName(const GraphPtr& graph, unsigned int index); - armnn::Pooling2dDescriptor GetPoolingDescriptor(PoolingDescriptor pooling2dDescriptor, - unsigned int layerIndex); + static armnn::Pooling2dDescriptor GetPoolingDescriptor(PoolingDescriptor pooling2dDescriptor, + unsigned int layerIndex); + static armnn::NormalizationDescriptor GetNormalizationDescriptor( + NormalizationDescriptorPtr normalizationDescriptor, unsigned int layerIndex); static armnn::TensorInfo OutputShapeOfReshape(const armnn::TensorInfo & inputTensorInfo, const std::vector & targetDimsIn); @@ -80,6 +83,7 @@ private: void ParseMinimum(GraphPtr graph, unsigned int layerIndex); void ParseMaximum(GraphPtr graph, unsigned int layerIndex); void ParseMultiplication(GraphPtr graph, unsigned int layerIndex); + void ParseNormalization(GraphPtr graph, unsigned int layerIndex); void ParsePermute(GraphPtr graph, unsigned int layerIndex); void ParsePooling2d(GraphPtr graph, unsigned int layerIndex); void ParseReshape(GraphPtr graph, unsigned int layerIndex); diff --git a/src/armnnDeserializer/DeserializerSupport.md b/src/armnnDeserializer/DeserializerSupport.md index bb2f0637ac..cf8f6dea2d 100644 --- a/src/armnnDeserializer/DeserializerSupport.md +++ b/src/armnnDeserializer/DeserializerSupport.md @@ -18,6 +18,7 @@ The Arm NN SDK Deserialize parser currently supports the following layers: * Maximum * Minimum * Multiplication +* Normalization * Permute * Pooling2d * Reshape diff --git a/src/armnnDeserializer/test/DeserializeNormalization.cpp b/src/armnnDeserializer/test/DeserializeNormalization.cpp new file mode 100644 index 0000000000..eb7e958c5b --- /dev/null +++ b/src/armnnDeserializer/test/DeserializeNormalization.cpp @@ -0,0 +1,143 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include +#include "ParserFlatbuffersSerializeFixture.hpp" +#include "../Deserializer.hpp" + +#include +#include + +BOOST_AUTO_TEST_SUITE(Deserializer) + +struct NormalizationFixture : public ParserFlatbuffersSerializeFixture +{ + explicit NormalizationFixture(const std::string &inputShape, + const std::string & outputShape, + const std::string &dataType, + const std::string &normAlgorithmChannel, + const std::string &normAlgorithmMethod, + const std::string &dataLayout) + { + 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"(, + quantizationScale: 0.5, + quantizationOffset: 0 + }, + }] + }, + } + }, + }, + { + layer_type: "NormalizationLayer", + layer : { + base: { + index:1, + layerName: "NormalizationLayer", + layerType: "Normalization", + inputSlots: [{ + index: 0, + connection: {sourceLayerIndex:0, outputSlotIndex:0 }, + }], + outputSlots: [{ + index: 0, + tensorInfo: { + dimensions: )" + outputShape + R"(, + dataType: )" + dataType + R"( + }, + }], + }, + descriptor: { + normChannelType: )" + normAlgorithmChannel + R"(, + normMethodType: )" + normAlgorithmMethod + R"(, + normSize: 3, + alpha: 1, + beta: 1, + k: 1, + dataLayout: )" + dataLayout + R"( + } + }, + }, + { + layer_type: "OutputLayer", + layer: { + base:{ + layerBindingId: 0, + 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"); + } +}; + +struct FloatNhwcLocalBrightnessAcrossNormalizationFixture : NormalizationFixture +{ + FloatNhwcLocalBrightnessAcrossNormalizationFixture() : NormalizationFixture("[ 2, 2, 2, 1 ]", "[ 2, 2, 2, 1 ]", + "Float32", "0", "0", "NHWC") {} +}; + + +BOOST_FIXTURE_TEST_CASE(Float32NormalizationNhwcDataLayout, FloatNhwcLocalBrightnessAcrossNormalizationFixture) +{ + RunTest<4, armnn::DataType::Float32>(0, { 1.0f, 2.0f, 3.0f, 4.0f, + 5.0f, 6.0f, 7.0f, 8.0f }, + { 0.5f, 0.400000006f, 0.300000012f, 0.235294119f, + 0.192307696f, 0.16216217f, 0.140000001f, 0.123076923f }); +} + +struct FloatNchwLocalBrightnessWithinNormalizationFixture : NormalizationFixture +{ + FloatNchwLocalBrightnessWithinNormalizationFixture() : NormalizationFixture("[ 2, 1, 2, 2 ]", "[ 2, 1, 2, 2 ]", + "Float32", "1", "0", "NCHW") {} +}; + +BOOST_FIXTURE_TEST_CASE(Float32NormalizationNchwDataLayout, FloatNchwLocalBrightnessWithinNormalizationFixture) +{ + RunTest<4, armnn::DataType::Float32>(0, { 1.0f, 2.0f, 3.0f, 4.0f, + 5.0f, 6.0f, 7.0f, 8.0f }, + { 0.0322581f, 0.0645161f, 0.0967742f, 0.1290323f, + 0.0285714f, 0.0342857f, 0.04f, 0.0457143f }); +} + + +BOOST_AUTO_TEST_SUITE_END() \ No newline at end of file diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs index b59adcf82b..cde0087d6f 100644 --- a/src/armnnSerializer/ArmnnSchema.fbs +++ b/src/armnnSerializer/ArmnnSchema.fbs @@ -99,7 +99,8 @@ enum LayerType : uint { Division = 15, Minimum = 16, Equal = 17, - Maximum = 18 + Maximum = 18, + Normalization = 19 } // Base layer table to be used as part of other layers @@ -298,6 +299,31 @@ table BatchToSpaceNdDescriptor { dataLayout:DataLayout; } +enum NormalizationAlgorithmChannel : byte { + Across = 0, + Within = 1 +} + +enum NormalizationAlgorithmMethod : byte { + LocalBrightness = 0, + LocalContrast = 1 +} + +table NormalizationLayer { + base:LayerBase; + descriptor:NormalizationDescriptor; +} + +table NormalizationDescriptor { + normChannelType:NormalizationAlgorithmChannel = Across; + normMethodType:NormalizationAlgorithmMethod = LocalBrightness; + normSize:uint; + alpha:float; + beta:float; + k:float; + dataLayout:DataLayout = NCHW; +} + union Layer { ActivationLayer, AdditionLayer, @@ -317,7 +343,8 @@ union Layer { DivisionLayer, MinimumLayer, EqualLayer, - MaximumLayer + MaximumLayer, + NormalizationLayer } table AnyLayer { diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp index a94a319a4c..2000726526 100644 --- a/src/armnnSerializer/Serializer.cpp +++ b/src/armnnSerializer/Serializer.cpp @@ -470,6 +470,29 @@ void SerializerVisitor::VisitSpaceToBatchNdLayer(const armnn::IConnectableLayer* CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_SpaceToBatchNdLayer); } +void SerializerVisitor::VisitNormalizationLayer(const armnn::IConnectableLayer* layer, + const armnn::NormalizationDescriptor& descriptor, + const char* name) +{ + auto fbNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Normalization); + + auto fbNormalizationDescriptor = serializer::CreateNormalizationDescriptor( + m_flatBufferBuilder, + GetFlatBufferNormalizationAlgorithmChannel(descriptor.m_NormChannelType), + GetFlatBufferNormalizationAlgorithmMethod(descriptor.m_NormMethodType), + descriptor.m_NormSize, + descriptor.m_Alpha, + descriptor.m_Beta, + descriptor.m_K, + GetFlatBufferDataLayout(descriptor.m_DataLayout)); + + auto flatBufferLayer = serializer::CreateNormalizationLayer(m_flatBufferBuilder, + fbNormalizationBaseLayer, + fbNormalizationDescriptor); + + CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_NormalizationLayer); +} + fb::Offset SerializerVisitor::CreateLayerBase(const IConnectableLayer* layer, const serializer::LayerType layerType) { diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp index 3d6f1b5700..7e6097c465 100644 --- a/src/armnnSerializer/Serializer.hpp +++ b/src/armnnSerializer/Serializer.hpp @@ -118,6 +118,9 @@ public: const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor, const char* name = nullptr) override; + void VisitNormalizationLayer(const armnn::IConnectableLayer* layer, + const armnn::NormalizationDescriptor& normalizationDescriptor, + const char* name = nullptr) override; private: /// Creates the Input Slots and Output Slots and LayerBase for the layer. diff --git a/src/armnnSerializer/SerializerSupport.md b/src/armnnSerializer/SerializerSupport.md index 83987f98d7..d018a35c3a 100644 --- a/src/armnnSerializer/SerializerSupport.md +++ b/src/armnnSerializer/SerializerSupport.md @@ -18,6 +18,7 @@ The Arm NN SDK Serializer currently supports the following layers: * Maximum * Minimum * Multiplication +* Normalization * Permute * Pooling2d * Reshape diff --git a/src/armnnSerializer/SerializerUtils.cpp b/src/armnnSerializer/SerializerUtils.cpp index 592f258b81..bfe795c8c4 100644 --- a/src/armnnSerializer/SerializerUtils.cpp +++ b/src/armnnSerializer/SerializerUtils.cpp @@ -96,4 +96,32 @@ armnnSerializer::PaddingMethod GetFlatBufferPaddingMethod(armnn::PaddingMethod p } } +armnnSerializer::NormalizationAlgorithmChannel GetFlatBufferNormalizationAlgorithmChannel( + armnn::NormalizationAlgorithmChannel normalizationAlgorithmChannel) +{ + switch (normalizationAlgorithmChannel) + { + case armnn::NormalizationAlgorithmChannel::Across: + return armnnSerializer::NormalizationAlgorithmChannel::NormalizationAlgorithmChannel_Across; + case armnn::NormalizationAlgorithmChannel::Within: + return armnnSerializer::NormalizationAlgorithmChannel::NormalizationAlgorithmChannel_Within; + default: + return armnnSerializer::NormalizationAlgorithmChannel::NormalizationAlgorithmChannel_Across; + } +} + +armnnSerializer::NormalizationAlgorithmMethod GetFlatBufferNormalizationAlgorithmMethod( + armnn::NormalizationAlgorithmMethod normalizationAlgorithmMethod) +{ + switch (normalizationAlgorithmMethod) + { + case armnn::NormalizationAlgorithmMethod::LocalBrightness: + return armnnSerializer::NormalizationAlgorithmMethod::NormalizationAlgorithmMethod_LocalBrightness; + case armnn::NormalizationAlgorithmMethod::LocalContrast: + return armnnSerializer::NormalizationAlgorithmMethod::NormalizationAlgorithmMethod_LocalContrast; + default: + return armnnSerializer::NormalizationAlgorithmMethod::NormalizationAlgorithmMethod_LocalBrightness; + } +} + } // namespace armnnSerializer \ No newline at end of file diff --git a/src/armnnSerializer/SerializerUtils.hpp b/src/armnnSerializer/SerializerUtils.hpp index 9b1dff9112..29cda0d629 100644 --- a/src/armnnSerializer/SerializerUtils.hpp +++ b/src/armnnSerializer/SerializerUtils.hpp @@ -24,4 +24,10 @@ armnnSerializer::OutputShapeRounding GetFlatBufferOutputShapeRounding( armnnSerializer::PaddingMethod GetFlatBufferPaddingMethod(armnn::PaddingMethod paddingMethod); +armnnSerializer::NormalizationAlgorithmChannel GetFlatBufferNormalizationAlgorithmChannel( + armnn::NormalizationAlgorithmChannel normalizationAlgorithmChannel); + +armnnSerializer::NormalizationAlgorithmMethod GetFlatBufferNormalizationAlgorithmMethod( + armnn::NormalizationAlgorithmMethod normalizationAlgorithmMethod); + } // namespace armnnSerializer diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp index 7e4ff8c614..271b3e71bd 100644 --- a/src/armnnSerializer/test/SerializerTests.cpp +++ b/src/armnnSerializer/test/SerializerTests.cpp @@ -891,6 +891,54 @@ BOOST_AUTO_TEST_CASE(SerializeDivision) deserializedNetwork->Accept(nameChecker); } +BOOST_AUTO_TEST_CASE(SerializeDeserializeNormalization) +{ + class VerifyNormalizationName : public armnn::LayerVisitorBase + { + public: + void VisitNormalizationLayer(const armnn::IConnectableLayer*, + const armnn::NormalizationDescriptor& normalizationDescriptor, + const char* name) override + { + BOOST_TEST(name == "NormalizationLayer"); + } + }; + + unsigned int inputShape[] = {2, 1, 2, 2}; + unsigned int outputShape[] = {2, 1, 2, 2}; + + armnn::NormalizationDescriptor desc; + desc.m_DataLayout = armnn::DataLayout::NCHW; + desc.m_NormSize = 3; + desc.m_Alpha = 1; + desc.m_Beta = 1; + desc.m_K = 1; + + auto inputTensorInfo = armnn::TensorInfo(4, inputShape, armnn::DataType::Float32); + auto outputTensorInfo = armnn::TensorInfo(4, outputShape, armnn::DataType::Float32); + + armnn::INetworkPtr network = armnn::INetwork::Create(); + armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0); + armnn::IConnectableLayer* const normalizationLayer = network->AddNormalizationLayer(desc, "NormalizationLayer"); + armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0); + + inputLayer->GetOutputSlot(0).Connect(normalizationLayer->GetInputSlot(0)); + inputLayer->GetOutputSlot(0).SetTensorInfo(inputTensorInfo); + normalizationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0)); + normalizationLayer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network)); + BOOST_CHECK(deserializedNetwork); + + VerifyNormalizationName nameChecker; + deserializedNetwork->Accept(nameChecker); + + CheckDeserializedNetworkAgainstOriginal(*network, + *deserializedNetwork, + {inputTensorInfo.GetShape()}, + {outputTensorInfo.GetShape()}); +} + BOOST_AUTO_TEST_CASE(SerializeDeserializeEqual) { class VerifyEqualName : public armnn::LayerVisitorBase @@ -932,5 +980,4 @@ BOOST_AUTO_TEST_CASE(SerializeDeserializeEqual) {outputTensorInfo.GetShape()}, {0, 1}); } - BOOST_AUTO_TEST_SUITE_END() -- cgit v1.2.1