armnnDeserializer Namespace Reference

Classes
struct	BindingPointInfo
class	IDeserializer

Typedefs
using	IDeserializerPtr = std::unique_ptr< IDeserializer, void(*)(IDeserializer *parser)>
using	ConstTensorRawPtr = const armnnSerializer::ConstTensor *
using	GraphPtr = const armnnSerializer::SerializedGraph *
using	TensorRawPtr = const armnnSerializer::TensorInfo *
using	Pooling2dDescriptor = const armnnSerializer::Pooling2dDescriptor *
using	Pooling3dDescriptor = const armnnSerializer::Pooling3dDescriptor *
using	NormalizationDescriptorPtr = const armnnSerializer::NormalizationDescriptor *
using	LstmDescriptorPtr = const armnnSerializer::LstmDescriptor *
using	LstmInputParamsPtr = const armnnSerializer::LstmInputParams *
using	QLstmDescriptorPtr = const armnnSerializer::QLstmDescriptor *
using	QunatizedLstmInputParamsPtr = const armnnSerializer::QuantizedLstmInputParams *
using	TensorRawPtrVector = std::vector< TensorRawPtr >
using	LayerRawPtr = const armnnSerializer::LayerBase *
using	LayerBaseRawPtr = const armnnSerializer::LayerBase *
using	LayerBaseRawPtrVector = std::vector< LayerBaseRawPtr >
using	UnidirectionalSequenceLstmDescriptorPtr = const armnnSerializer::UnidirectionalSequenceLstmDescriptor *

Functions
bool	CheckShape (const armnn::TensorShape &actual, const std::vector< uint32_t > &expected)
armnn::DataLayout	ToDataLayout (armnnSerializer::DataLayout dataLayout)
armnn::ActivationFunction	ToActivationFunction (armnnSerializer::ActivationFunction function)
armnn::ArgMinMaxFunction	ToArgMinMaxFunction (armnnSerializer::ArgMinMaxFunction function)
armnn::ComparisonOperation	ToComparisonOperation (armnnSerializer::ComparisonOperation operation)
armnn::ReduceOperation	ToReduceOperation (armnnSerializer::ReduceOperation operation)
armnn::LogicalBinaryOperation	ToLogicalBinaryOperation (armnnSerializer::LogicalBinaryOperation operation)
armnn::UnaryOperation	ToUnaryOperation (armnnSerializer::UnaryOperation operation)
armnn::PaddingMode	ToPaddingMode (armnnSerializer::PaddingMode paddingMode)
armnn::ResizeMethod	ToResizeMethod (armnnSerializer::ResizeMethod method)
armnn::TensorInfo	ToTensorInfo (TensorRawPtr tensorPtr)
armnn::ConstTensor	ToConstTensor (ConstTensorRawPtr constTensorPtr)
const armnnSerializer::OriginsDescriptor *	GetOriginsDescriptor (const armnnSerializer::SerializedGraph *graph, unsigned int layerIndex)

Typedef Documentation

ConstTensorRawPtr

using ConstTensorRawPtr = const armnnSerializer::ConstTensor *

Definition at line 18 of file Deserializer.hpp.

GraphPtr

using GraphPtr = const armnnSerializer::SerializedGraph *

Definition at line 19 of file Deserializer.hpp.

IDeserializerPtr

using IDeserializerPtr = std::unique_ptr<IDeserializer, void(*)(IDeserializer* parser)>

Definition at line 25 of file IDeserializer.hpp.

LayerBaseRawPtr

using LayerBaseRawPtr = const armnnSerializer::LayerBase *

Definition at line 30 of file Deserializer.hpp.

LayerBaseRawPtrVector

using LayerBaseRawPtrVector = std::vector<LayerBaseRawPtr>

Definition at line 31 of file Deserializer.hpp.

LayerRawPtr

using LayerRawPtr = const armnnSerializer::LayerBase *

Definition at line 29 of file Deserializer.hpp.

LstmDescriptorPtr

using LstmDescriptorPtr = const armnnSerializer::LstmDescriptor *

Definition at line 24 of file Deserializer.hpp.

LstmInputParamsPtr

using LstmInputParamsPtr = const armnnSerializer::LstmInputParams *

Definition at line 25 of file Deserializer.hpp.

NormalizationDescriptorPtr

using NormalizationDescriptorPtr = const armnnSerializer::NormalizationDescriptor *

Definition at line 23 of file Deserializer.hpp.

Pooling2dDescriptor

using Pooling2dDescriptor = const armnnSerializer::Pooling2dDescriptor *

Definition at line 21 of file Deserializer.hpp.

Pooling3dDescriptor

using Pooling3dDescriptor = const armnnSerializer::Pooling3dDescriptor *

Definition at line 22 of file Deserializer.hpp.

QLstmDescriptorPtr

using QLstmDescriptorPtr = const armnnSerializer::QLstmDescriptor *

Definition at line 26 of file Deserializer.hpp.

QunatizedLstmInputParamsPtr

using QunatizedLstmInputParamsPtr = const armnnSerializer::QuantizedLstmInputParams *

Definition at line 27 of file Deserializer.hpp.

TensorRawPtr

using TensorRawPtr = const armnnSerializer::TensorInfo *

Definition at line 20 of file Deserializer.hpp.

TensorRawPtrVector

using TensorRawPtrVector = std::vector<TensorRawPtr>

Definition at line 28 of file Deserializer.hpp.

UnidirectionalSequenceLstmDescriptorPtr

using UnidirectionalSequenceLstmDescriptorPtr = const armnnSerializer::UnidirectionalSequenceLstmDescriptor *

Definition at line 32 of file Deserializer.hpp.

Function Documentation

CheckShape()

bool armnnDeserializer::CheckShape	(	const armnn::TensorShape &	actual,
		const std::vector< uint32_t > &	expected
	)

Definition at line 188 of file Deserializer.cpp.

{
    const unsigned int actualSize = actual.GetNumDimensions();
    if (actualSize != expected.size())
    {
        return false;
    }
 
    for (unsigned int i = 0u; i < actualSize; i++)
    {
        if (actual[i] != static_cast<unsigned int>(expected[i]))
        {
            return false;
        }
    }
 
    return true;
}

References TensorShape::GetNumDimensions().

GetOriginsDescriptor()

const armnnSerializer::OriginsDescriptor* armnnDeserializer::GetOriginsDescriptor	(	const armnnSerializer::SerializedGraph *	graph,
		unsigned int	layerIndex
	)

Definition at line 1967 of file Deserializer.cpp.

{
    auto layerType = graph->layers()->Get(layerIndex)->layer_type();
 
    switch (layerType)
    {
        case Layer::Layer_ConcatLayer:
            return graph->layers()->Get(layerIndex)->layer_as_ConcatLayer()->descriptor();
        case Layer::Layer_MergerLayer:
            return graph->layers()->Get(layerIndex)->layer_as_MergerLayer()->descriptor();
        default:
            throw armnn::Exception("unknown layer type, should be concat or merger");
    }
}

ToActivationFunction()

armnn::ActivationFunction armnnDeserializer::ToActivationFunction

(

armnnSerializer::ActivationFunction

function

)

Definition at line 470 of file Deserializer.cpp.

{
    switch (function)
    {
        case armnnSerializer::ActivationFunction_Sigmoid:
            return armnn::ActivationFunction::Sigmoid;
        case armnnSerializer::ActivationFunction_TanH:
            return armnn::ActivationFunction::TanH;
        case armnnSerializer::ActivationFunction_Linear:
            return armnn::ActivationFunction::Linear;
        case armnnSerializer::ActivationFunction_ReLu:
            return armnn::ActivationFunction::ReLu;
        case armnnSerializer::ActivationFunction_BoundedReLu:
            return armnn::ActivationFunction::BoundedReLu;
        case armnnSerializer::ActivationFunction_LeakyReLu:
            return armnn::ActivationFunction::LeakyReLu;
        case armnnSerializer::ActivationFunction_Abs:
            return armnn::ActivationFunction::Abs;
        case armnnSerializer::ActivationFunction_Sqrt:
            return armnn::ActivationFunction::Sqrt;
        case armnnSerializer::ActivationFunction_Square:
            return armnn::ActivationFunction::Square;
        case armnnSerializer::ActivationFunction_Elu:
            return armnn::ActivationFunction::Elu;
        case armnnSerializer::ActivationFunction_HardSwish:
            return armnn::ActivationFunction::HardSwish;
        default:
            return armnn::ActivationFunction::Sigmoid;
    }
}

References armnn::Abs, armnn::BoundedReLu, armnn::Elu, armnn::HardSwish, armnn::LeakyReLu, armnn::Linear, armnn::ReLu, armnn::Sigmoid, armnn::Sqrt, armnn::Square, and armnn::TanH.

ToArgMinMaxFunction()

armnn::ArgMinMaxFunction armnnDeserializer::ToArgMinMaxFunction

(

armnnSerializer::ArgMinMaxFunction

function

)

Definition at line 501 of file Deserializer.cpp.

{
    switch (function)
    {
        case armnnSerializer::ArgMinMaxFunction::ArgMinMaxFunction_Max:
            return armnn::ArgMinMaxFunction::Max;
        case armnnSerializer::ArgMinMaxFunction::ArgMinMaxFunction_Min:
        default:
            return armnn::ArgMinMaxFunction::Min;
    }
}

References armnn::Max, and armnn::Min.

ToComparisonOperation()

armnn::ComparisonOperation armnnDeserializer::ToComparisonOperation

(

armnnSerializer::ComparisonOperation

operation

)

Definition at line 513 of file Deserializer.cpp.

{
    switch (operation)
    {
        case armnnSerializer::ComparisonOperation::ComparisonOperation_Equal:
            return armnn::ComparisonOperation::Equal;
        case armnnSerializer::ComparisonOperation::ComparisonOperation_Greater:
            return armnn::ComparisonOperation::Greater;
        case armnnSerializer::ComparisonOperation::ComparisonOperation_GreaterOrEqual:
            return armnn::ComparisonOperation::GreaterOrEqual;
        case armnnSerializer::ComparisonOperation::ComparisonOperation_Less:
            return armnn::ComparisonOperation::Less;
        case armnnSerializer::ComparisonOperation::ComparisonOperation_LessOrEqual:
            return armnn::ComparisonOperation::LessOrEqual;
        case armnnSerializer::ComparisonOperation::ComparisonOperation_NotEqual:
        default:
            return armnn::ComparisonOperation::NotEqual;
    }
}

References armnn::Equal, armnn::Greater, armnn::GreaterOrEqual, armnn::Less, armnn::LessOrEqual, and armnn::NotEqual.

ToConstTensor()

armnn::ConstTensor armnnDeserializer::ToConstTensor

(

ConstTensorRawPtr

constTensorPtr

)

Definition at line 722 of file Deserializer.cpp.

{
    CHECK_CONST_TENSOR_PTR(constTensorPtr);
    armnn::TensorInfo tensorInfo = ToTensorInfo(constTensorPtr->info());
    tensorInfo.SetConstant();
 
    switch (constTensorPtr->data_type())
    {
        case ConstTensorData_ByteData:
        {
            auto byteData = constTensorPtr->data_as_ByteData()->data();
            CHECK_CONST_TENSOR_SIZE(byteData->size(), tensorInfo.GetNumElements());
            return armnn::ConstTensor(tensorInfo, byteData->data());
        }
        case ConstTensorData_ShortData:
        {
            auto shortData = constTensorPtr->data_as_ShortData()->data();
            CHECK_CONST_TENSOR_SIZE(shortData->size(), tensorInfo.GetNumElements());
            return armnn::ConstTensor(tensorInfo, shortData->data());
        }
        case ConstTensorData_IntData:
        {
            auto intData = constTensorPtr->data_as_IntData()->data();
            CHECK_CONST_TENSOR_SIZE(intData->size(), tensorInfo.GetNumElements());
            return armnn::ConstTensor(tensorInfo, intData->data());
        }
        case ConstTensorData_LongData:
        {
            auto longData = constTensorPtr->data_as_LongData()->data();
            CHECK_CONST_TENSOR_SIZE(longData->size(), tensorInfo.GetNumElements());
            return armnn::ConstTensor(tensorInfo, longData->data());
        }
        default:
        {
            CheckLocation location = CHECK_LOCATION();
            throw ParseException(fmt::format("Unsupported data type {0} = {1}. {2}",
                                             constTensorPtr->data_type(),
                                             EnumNameConstTensorData(constTensorPtr->data_type()),
                                             location.AsString()));
        }
    }
}

References CheckLocation::AsString(), CHECK_CONST_TENSOR_PTR, CHECK_CONST_TENSOR_SIZE, CHECK_LOCATION, TensorInfo::GetNumElements(), TensorInfo::SetConstant(), and ToTensorInfo().

ToDataLayout()

armnn::DataLayout armnnDeserializer::ToDataLayout

(

armnnSerializer::DataLayout

dataLayout

)

Definition at line 454 of file Deserializer.cpp.

{
    switch (dataLayout)
    {
        case armnnSerializer::DataLayout::DataLayout_NHWC:
            return armnn::DataLayout::NHWC;
        case armnnSerializer::DataLayout::DataLayout_NDHWC:
            return armnn::DataLayout::NDHWC;
        case armnnSerializer::DataLayout::DataLayout_NCDHW:
            return armnn::DataLayout::NCDHW;
        case armnnSerializer::DataLayout::DataLayout_NCHW:
        default:
            return armnn::DataLayout::NCHW;
    }
}

References armnn::NCDHW, armnn::NCHW, armnn::NDHWC, and armnn::NHWC.

ToLogicalBinaryOperation()

armnn::LogicalBinaryOperation armnnDeserializer::ToLogicalBinaryOperation

(

armnnSerializer::LogicalBinaryOperation

operation

)

Definition at line 552 of file Deserializer.cpp.

{
    switch (operation)
    {
        case armnnSerializer::LogicalBinaryOperation::LogicalBinaryOperation_LogicalAnd:
            return armnn::LogicalBinaryOperation::LogicalAnd;
        case armnnSerializer::LogicalBinaryOperation::LogicalBinaryOperation_LogicalOr:
            return armnn::LogicalBinaryOperation::LogicalOr;
        default:
            throw armnn::InvalidArgumentException("Logical Binary operation unknown");
    }
}

References armnn::LogicalAnd, and armnn::LogicalOr.

ToPaddingMode()

armnn::PaddingMode armnnDeserializer::ToPaddingMode

(

armnnSerializer::PaddingMode

paddingMode

)

Definition at line 590 of file Deserializer.cpp.

{
    switch (paddingMode)
    {
        case armnnSerializer::PaddingMode::PaddingMode_Reflect:
            return armnn::PaddingMode::Reflect;
        case armnnSerializer::PaddingMode::PaddingMode_Symmetric:
            return armnn::PaddingMode::Symmetric;
        default:
            return armnn::PaddingMode::Constant;
    }
}

References armnn::Constant, armnn::Reflect, and armnn::Symmetric.

ToReduceOperation()

armnn::ReduceOperation armnnDeserializer::ToReduceOperation

(

armnnSerializer::ReduceOperation

operation

)

Definition at line 533 of file Deserializer.cpp.

{
    switch (operation)
    {
        case armnnSerializer::ReduceOperation::ReduceOperation_Sum:
            return armnn::ReduceOperation::Sum;
        case armnnSerializer::ReduceOperation::ReduceOperation_Max:
            return armnn::ReduceOperation::Max;
        case armnnSerializer::ReduceOperation::ReduceOperation_Mean:
            return armnn::ReduceOperation::Mean;
        case armnnSerializer::ReduceOperation::ReduceOperation_Min:
            return armnn::ReduceOperation::Min;
        case armnnSerializer::ReduceOperation::ReduceOperation_Prod:
            return armnn::ReduceOperation::Prod;
        default:
            return armnn::ReduceOperation::Sum;
    }
}

References armnn::Max, armnn::Mean, armnn::Min, armnn::Prod, and armnn::Sum.

ToResizeMethod()

armnn::ResizeMethod armnnDeserializer::ToResizeMethod

(

armnnSerializer::ResizeMethod

method

)

Definition at line 603 of file Deserializer.cpp.

{
    switch (method)
    {
        case armnnSerializer::ResizeMethod_NearestNeighbor:
            return armnn::ResizeMethod::NearestNeighbor;
        case armnnSerializer::ResizeMethod_Bilinear:
            return armnn::ResizeMethod::Bilinear;
        default:
            return armnn::ResizeMethod::NearestNeighbor;
    }
}

References armnn::Bilinear, and armnn::NearestNeighbor.

ToTensorInfo()

armnn::TensorInfo armnnDeserializer::ToTensorInfo

(

TensorRawPtr

tensorPtr

)

Definition at line 616 of file Deserializer.cpp.

{
    armnn::DataType type;
    CHECK_TENSOR_PTR(tensorPtr);
 
    switch (tensorPtr->dataType())
    {
        case DataType_QAsymmS8:
            type = armnn::DataType::QAsymmS8;
            break;
        case DataType_QSymmS8:
            type = armnn::DataType::QSymmS8;
            break;
        case DataType_QuantisedAsymm8:
        case DataType_QAsymmU8:
            type = armnn::DataType::QAsymmU8;
            break;
        case DataType_QSymmS16:
        case DataType_QuantisedSymm16:
            type = armnn::DataType::QSymmS16;
            break;
        case DataType_Signed32:
            type = armnn::DataType::Signed32;
            break;
        case DataType_Signed64:
            type = armnn::DataType::Signed64;
            break;
        case DataType_Float32:
            type = armnn::DataType::Float32;
            break;
        case DataType_Float16:
            type = armnn::DataType::Float16;
            break;
        case DataType_Boolean:
            type = armnn::DataType::Boolean;
            break;
        default:
        {
            CheckLocation location = CHECK_LOCATION();
            throw ParseException(fmt::format("Unsupported data type {0} = {1}. {2}",
                                             tensorPtr->dataType(),
                                             EnumNameDataType(tensorPtr->dataType()),
                                             location.AsString()));
        }
    }
 
    float quantizationScale = tensorPtr->quantizationScale();
    int32_t quantizationOffset = tensorPtr->quantizationOffset();
 
    if (tensorPtr->dimensionality() == static_cast<unsigned int>(Dimensionality::Scalar))
    {
        return armnn::TensorInfo(TensorShape{armnn::Dimensionality::Scalar},
                                 type,
                                 quantizationScale,
                                 quantizationOffset);
    }
    else if (tensorPtr->dimensionality() == static_cast<unsigned int>(Dimensionality::NotSpecified))
    {
        armnn::TensorInfo result(TensorShape{Dimensionality::NotSpecified},
                                 type,
                                 quantizationScale,
                                 quantizationOffset);
        return result;
    }
 
    auto dimensions = tensorPtr->dimensions();
    unsigned int size = dimensions->size();
    std::vector<unsigned int> outputDims(dimensions->begin(), dimensions->begin() + size);
    bool dimensionsSpecificity[armnn::MaxNumOfTensorDimensions];
    std::fill_n(dimensionsSpecificity, armnn::MaxNumOfTensorDimensions, true);
    // For backwards compatibility check if the dimensionSpecificity vector is present first.
    // The default is to have dimensionSpecificity set to all true's anyway.
    if (tensorPtr->dimensionSpecificity() != nullptr)
    {
        auto dimensionSpecificity = tensorPtr->dimensionSpecificity();
        size = dimensionSpecificity->size();
        for (unsigned int i = 0; i < size; ++i)
        {
            dimensionsSpecificity[i] = dimensionSpecificity->Get(i);
        }
    }
    // Construct a TensorShape
    TensorShape shape(size, outputDims.data(), dimensionsSpecificity);
 
    auto quantizationScales = tensorPtr->quantizationScales();
    if (quantizationScales)
    {
        unsigned int quantizationScalesSize = quantizationScales->size();
        std::vector<float> scales(quantizationScales->begin(), quantizationScales->begin() + quantizationScalesSize);
        unsigned int quantizationDim = tensorPtr->quantizationDim();
        armnn::TensorInfo result(shape,
                                 type,
                                 scales,
                                 quantizationDim);
        return result;
    }
 
    // two statements (on purpose) for easier debugging:
    armnn::TensorInfo result(shape,
                             type,
                             quantizationScale,
                             quantizationOffset);
    
    return result;
}

References CheckLocation::AsString(), armnn::Boolean, CHECK_LOCATION, CHECK_TENSOR_PTR, armnn::Float16, armnn::Float32, armnn::MaxNumOfTensorDimensions, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, armnn::QSymmS8, armnn::Scalar, armnn::Signed32, and armnn::Signed64.

Referenced by TfLiteParserImpl::GetNetworkInputBindingInfo(), TfLiteParserImpl::GetNetworkOutputBindingInfo(), and ToConstTensor().

ToUnaryOperation()

armnn::UnaryOperation armnnDeserializer::ToUnaryOperation

(

armnnSerializer::UnaryOperation

operation

)

Definition at line 565 of file Deserializer.cpp.

{
    switch (operation)
    {
        case armnnSerializer::UnaryOperation::UnaryOperation_Abs:
            return armnn::UnaryOperation::Abs;
        case armnnSerializer::UnaryOperation::UnaryOperation_Rsqrt:
            return armnn::UnaryOperation::Rsqrt;
        case armnnSerializer::UnaryOperation::UnaryOperation_Sqrt:
            return armnn::UnaryOperation::Sqrt;
        case armnnSerializer::UnaryOperation::UnaryOperation_Exp:
            return armnn::UnaryOperation::Exp;
        case armnnSerializer::UnaryOperation::UnaryOperation_Neg:
            return armnn::UnaryOperation::Neg;
        case armnnSerializer::UnaryOperation::UnaryOperation_LogicalNot:
            return armnn::UnaryOperation::LogicalNot;
        case armnnSerializer::UnaryOperation::UnaryOperation_Log:
            return armnn::UnaryOperation::Log;
        case armnnSerializer::UnaryOperation::UnaryOperation_Sin:
            return armnn::UnaryOperation::Sin;
        default:
            throw armnn::InvalidArgumentException("Unary operation unknown");
    }
}

References armnn::Abs, armnn::Exp, armnn::Log, armnn::LogicalNot, armnn::Neg, armnn::Rsqrt, armnn::Sin, and armnn::Sqrt.