diff options
Diffstat (limited to 'src/armnnDeserializeParser')
| -rw-r--r-- | src/armnnDeserializeParser/DeserializeParser.cpp | 102 | ||||
| -rw-r--r-- | src/armnnDeserializeParser/DeserializeParser.hpp | 2 | ||||
| -rw-r--r-- | src/armnnDeserializeParser/test/DeserializeConvolution2d.cpp | 142 |
3 files changed, 246 insertions, 0 deletions
diff --git a/src/armnnDeserializeParser/DeserializeParser.cpp b/src/armnnDeserializeParser/DeserializeParser.cpp index 9af5087cff..0259f89db4 100644 --- a/src/armnnDeserializeParser/DeserializeParser.cpp +++ b/src/armnnDeserializeParser/DeserializeParser.cpp @@ -121,9 +121,23 @@ void CheckTensorPtr(DeserializeParser::TensorRawPtr rawPtr, } } +void CheckConstTensorPtr(DeserializeParser::ConstTensorRawPtr rawPtr, + const CheckLocation& location) +{ + if (rawPtr == nullptr) + { + throw ParseException(boost::str(boost::format("%1% was called with a null const tensor pointer. at %2%") % + location.m_Function % + location.FileLine())); + } +} + #define CHECK_TENSOR_PTR(TENSOR_PTR) \ CheckTensorPtr(TENSOR_PTR, CHECK_LOCATION()) +#define CHECK_CONST_TENSOR_PTR(TENSOR_PTR) \ + CheckConstTensorPtr(TENSOR_PTR, CHECK_LOCATION()) + #define CHECK_LAYERS(GRAPH, LAYERS_INDEX, LAYER_INDEX) \ CheckLayers(GRAPH, LAYERS_INDEX, LAYER_INDEX, CHECK_LOCATION()) @@ -157,6 +171,7 @@ m_ParserFunctions(Layer_MAX+1, &DeserializeParser::ParseUnsupportedLayer) { // register supported layers m_ParserFunctions[Layer_AdditionLayer] = &DeserializeParser::ParseAdd; + m_ParserFunctions[Layer_Convolution2dLayer] = &DeserializeParser::ParseConvolution2d; m_ParserFunctions[Layer_MultiplicationLayer] = &DeserializeParser::ParseMultiplication; m_ParserFunctions[Layer_Pooling2dLayer] = &DeserializeParser::ParsePooling2d; m_ParserFunctions[Layer_ReshapeLayer] = &DeserializeParser::ParseReshape; @@ -171,6 +186,8 @@ DeserializeParser::LayerBaseRawPtr DeserializeParser::GetBaseLayer(const GraphPt { case Layer::Layer_AdditionLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_AdditionLayer()->base(); + case Layer::Layer_Convolution2dLayer: + return graphPtr->layers()->Get(layerIndex)->layer_as_Convolution2dLayer()->base(); case Layer::Layer_InputLayer: return graphPtr->layers()->Get(layerIndex)->layer_as_InputLayer()->base()->base(); case Layer::Layer_MultiplicationLayer: @@ -206,6 +223,18 @@ int32_t DeserializeParser::GetBindingLayerInfo(const GraphPtr& graphPtr, unsigne return 0; } +armnn::DataLayout ToDataLayout(armnn::armnnSerializer::DataLayout dataLayout) +{ + switch (dataLayout) + { + case armnn::armnnSerializer::DataLayout::DataLayout_NHWC: + return armnn::DataLayout::NHWC; + case armnn::armnnSerializer::DataLayout::DataLayout_NCHW: + default: + return armnn::DataLayout::NCHW; + } +} + armnn::TensorInfo ToTensorInfo(DeserializeParser::TensorRawPtr tensorPtr) { armnn::DataType type; @@ -216,6 +245,9 @@ armnn::TensorInfo ToTensorInfo(DeserializeParser::TensorRawPtr tensorPtr) case DataType_QuantisedAsymm8: type = armnn::DataType::QuantisedAsymm8; break; + case DataType_Signed32: + type = armnn::DataType::Signed32; + break; case DataType_Float32: type = armnn::DataType::Float32; break; @@ -252,6 +284,33 @@ armnn::TensorInfo ToTensorInfo(DeserializeParser::TensorRawPtr tensorPtr) return result; } +armnn::ConstTensor ToConstTensor(DeserializeParser::ConstTensorRawPtr constTensorPtr) +{ + CHECK_CONST_TENSOR_PTR(constTensorPtr); + armnn::TensorInfo tensorInfo = ToTensorInfo(constTensorPtr->info()); + + switch (constTensorPtr->data_type()) + { + case ConstTensorData_ByteData: + return armnn::ConstTensor(tensorInfo, constTensorPtr->data_as_ByteData()->data()->data()); + case ConstTensorData_ShortData: + return armnn::ConstTensor(tensorInfo, constTensorPtr->data_as_ShortData()->data()->data()); + case ConstTensorData_IntData: + return armnn::ConstTensor(tensorInfo, constTensorPtr->data_as_IntData()->data()->data()); + case ConstTensorData_LongData: + return armnn::ConstTensor(tensorInfo, constTensorPtr->data_as_LongData()->data()->data()); + default: + { + CheckLocation location = CHECK_LOCATION(); + throw ParseException( + boost::str(boost::format("Unsupported data type %1% = %2%. %3%") % + constTensorPtr->data_type() % + EnumNameConstTensorData(constTensorPtr->data_type()) % + location.AsString())); + } + } +} + DeserializeParser::LayerBaseRawPtrVector DeserializeParser::GetGraphInputs(const GraphPtr& graphPtr) { @@ -603,6 +662,49 @@ void DeserializeParser::ParseAdd(unsigned int layerIndex) RegisterOutputSlots(layerIndex, layer); } +void DeserializeParser::ParseConvolution2d(unsigned int layerIndex) +{ + CHECK_LAYERS(m_Graph, 0, layerIndex); + auto inputs = GetInputs(m_Graph, layerIndex); + CHECK_LOCATION(); + CHECK_VALID_SIZE(inputs.size(), 1); + + auto outputs = GetOutputs(m_Graph, layerIndex); + CHECK_VALID_SIZE(outputs.size(), 1); + + auto layerName = boost::str(boost::format("Convolution2d:%1%") % layerIndex); + + auto serializerLayer = m_Graph->layers()->Get(layerIndex)->layer_as_Convolution2dLayer(); + auto serializerDescriptor = serializerLayer->descriptor(); + + armnn::Convolution2dDescriptor descriptor; + descriptor.m_PadLeft = serializerDescriptor->padLeft(); + descriptor.m_PadRight = serializerDescriptor->padRight(); + descriptor.m_PadTop = serializerDescriptor->padTop(); + descriptor.m_PadBottom = serializerDescriptor->padBottom(); + descriptor.m_StrideX = serializerDescriptor->strideX(); + descriptor.m_StrideY = serializerDescriptor->strideY();; + descriptor.m_BiasEnabled = serializerDescriptor->biasEnabled();; + descriptor.m_DataLayout = ToDataLayout(serializerDescriptor->dataLayout()); + + armnn::ConstTensor weights = ToConstTensor(serializerLayer->weights()); + armnn::ConstTensor biases; + + if (descriptor.m_BiasEnabled) + { + biases = ToConstTensor(serializerLayer->biases()); + } + IConnectableLayer* layer = m_Network->AddConvolution2dLayer(descriptor, + weights, + biases, + layerName.c_str()); + armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]); + layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo); + + RegisterInputSlots(layerIndex, layer); + RegisterOutputSlots(layerIndex, layer); +} + void DeserializeParser::ParseMultiplication(unsigned int layerIndex) { CHECK_LAYERS(m_Graph, 0, layerIndex); diff --git a/src/armnnDeserializeParser/DeserializeParser.hpp b/src/armnnDeserializeParser/DeserializeParser.hpp index aee647c636..c295ee8b5f 100644 --- a/src/armnnDeserializeParser/DeserializeParser.hpp +++ b/src/armnnDeserializeParser/DeserializeParser.hpp @@ -15,6 +15,7 @@ class DeserializeParser : public IDeserializeParser { public: // Shorthands for deserializer types + using ConstTensorRawPtr = const armnn::armnnSerializer::ConstTensor *; using GraphPtr = const armnn::armnnSerializer::SerializedGraph *; using TensorRawPtr = const armnn::armnnSerializer::TensorInfo *; using PoolingDescriptor = const armnn::armnnSerializer::Pooling2dDescriptor *; @@ -68,6 +69,7 @@ private: void ParseUnsupportedLayer(unsigned int layerIndex); void ParseAdd(unsigned int layerIndex); + void ParseConvolution2d(unsigned int layerIndex); void ParseMultiplication(unsigned int layerIndex); void ParsePooling2d(unsigned int layerIndex); void ParseReshape(unsigned int layerIndex); diff --git a/src/armnnDeserializeParser/test/DeserializeConvolution2d.cpp b/src/armnnDeserializeParser/test/DeserializeConvolution2d.cpp new file mode 100644 index 0000000000..f3f6feb7a1 --- /dev/null +++ b/src/armnnDeserializeParser/test/DeserializeConvolution2d.cpp @@ -0,0 +1,142 @@ +// +// Copyright © 2017 Arm Ltd. All rights reserved. +// SPDX-License-Identifier: MIT +// + +#include <boost/test/unit_test.hpp> +#include "ParserFlatbuffersSerializeFixture.hpp" +#include "../DeserializeParser.hpp" + +#include <string> +#include <iostream> + +BOOST_AUTO_TEST_SUITE(DeserializeParser) + +struct Convolution2dFixture : public ParserFlatbuffersSerializeFixture +{ + explicit Convolution2dFixture(const std::string & inputShape1, + const std::string & outputShape, + const std::string & weightsShape, + const std::string & dataType) + { + 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: )" + inputShape1 + R"(, + dataType: )" + dataType + R"(, + quantizationScale: 0.5, + quantizationOffset: 0 + }, + }] + }, + } + }, + }, + { + layer_type: "Convolution2dLayer", + layer : { + base: { + index:1, + layerName: "Convolution2dLayer", + layerType: "Convolution2d", + inputSlots: [{ + index: 0, + connection: {sourceLayerIndex:0, outputSlotIndex:0 }, + }], + outputSlots: [{ + index: 0, + tensorInfo: { + dimensions: )" + outputShape + R"(, + dataType: )" + dataType + R"( + }, + }], + }, + descriptor: { + padLeft: 1, + padRight: 1, + padTop: 1, + padBottom: 1, + strideX: 2, + strideY: 2, + biasEnabled: false, + dataLayout: NHWC + }, + weights: { + info: { + dimensions: )" + weightsShape + R"(, + dataType: )" + dataType + R"( + }, + data_type: IntData, + data: { + data: [ + 1082130432, 1084227584, 1086324736, + 0 ,0 ,0 , + 1077936128, 1073741824, 1065353216 + ], + } + } + }, + }, + { + 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"( + }, + }], + } + }}, + }] + } + )"; + Setup(); + } +}; + +struct SimpleConvolution2dFixture : Convolution2dFixture +{ + SimpleConvolution2dFixture() : Convolution2dFixture("[ 1, 5, 5, 1 ]", + "[ 1, 3, 3, 1 ]", + "[ 1, 3, 3, 1 ]", + "Float32") {} +}; + +BOOST_FIXTURE_TEST_CASE(Convolution2dFloat32, SimpleConvolution2dFixture) +{ + RunTest<4, armnn::DataType::Float32>( + 0, + {{"InputLayer", {1, 5, 2, 3, 5, 8, 7, 3, 6, 3, 3, 3, 9, 1, 9, 4, 1, 8, 1, 3, 6, 8, 1, 9, 2}}}, + {{"OutputLayer", {23, 33, 24, 91, 99, 48, 26, 50, 19}}}); +} + +BOOST_AUTO_TEST_SUITE_END() |