#include <TfLiteParser.hpp>

Public Types
using	ModelPtr = std::unique_ptr< tflite::ModelT >

using	SubgraphPtr = std::unique_ptr< tflite::SubGraphT >

using	OperatorPtr = std::unique_ptr< tflite::OperatorT >

using	OperatorCodePtr = std::unique_ptr< tflite::OperatorCodeT >

using	TensorPtr = std::unique_ptr< tflite::TensorT >

using	TensorRawPtr = const tflite::TensorT *

using	TensorRawPtrVector = std::vector< TensorRawPtr >

using	TensorIdRawPtr = std::pair< size_t, TensorRawPtr >

using	TensorIdRawPtrVector = std::vector< TensorIdRawPtr >

using	BufferPtr = std::unique_ptr< tflite::BufferT >

using	BufferRawPtr = const tflite::BufferT *

Public Member Functions
armnn::INetworkPtr	CreateNetworkFromBinaryFile (const char *graphFile)
	Create the network from a flatbuffers binary file on disk. More...

armnn::INetworkPtr	CreateNetworkFromBinary (const std::vector< uint8_t > &binaryContent)
	Create the network from a flatbuffers binary. More...

BindingPointInfo	GetNetworkInputBindingInfo (size_t subgraphId, const std::string &name) const
	Retrieve binding info (layer id and tensor info) for the network input identified by the given layer name and subgraph id. More...

BindingPointInfo	GetNetworkOutputBindingInfo (size_t subgraphId, const std::string &name) const
	Retrieve binding info (layer id and tensor info) for the network output identified by the given layer name and subgraph id. More...

size_t	GetSubgraphCount () const
	Return the number of subgraphs in the parsed model. More...

std::vector< std::string >	GetSubgraphInputTensorNames (size_t subgraphId) const
	Return the input tensor names for a given subgraph. More...

std::vector< std::string >	GetSubgraphOutputTensorNames (size_t subgraphId) const
	Return the output tensor names for a given subgraph. More...

	TfLiteParserImpl (const armnn::Optional< ITfLiteParser::TfLiteParserOptions > &options=armnn::EmptyOptional())

	~TfLiteParserImpl ()=default

armnn::INetworkPtr	CreateNetworkFromBinaryAsDynamic (const std::vector< uint8_t > &binaryContent)

armnn::INetworkPtr	LoadModel (std::unique_ptr< tflite::ModelT > model)

Static Public Member Functions
static ModelPtr	LoadModelFromFile (const char *fileName)

static ModelPtr	LoadModelFromBinary (const uint8_t *binaryContent, size_t len)

static TensorRawPtrVector	GetInputs (const ModelPtr &model, size_t subgraphIndex, size_t operatorIndex)

static TensorRawPtrVector	GetOutputs (const ModelPtr &model, size_t subgraphIndex, size_t operatorIndex)

static TensorIdRawPtrVector	GetSubgraphInputs (const ModelPtr &model, size_t subgraphIndex)

static TensorIdRawPtrVector	GetSubgraphOutputs (const ModelPtr &model, size_t subgraphIndex)

static std::vector< int32_t > &	GetInputTensorIds (const ModelPtr &model, size_t subgraphIndex, size_t operatorIndex)

static std::vector< int32_t > &	GetOutputTensorIds (const ModelPtr &model, size_t subgraphIndex, size_t operatorIndex)

static BufferRawPtr	GetBuffer (const ModelPtr &model, size_t bufferIndex)

static armnn::TensorInfo	OutputShapeOfSqueeze (std::vector< uint32_t > squeezeDims, const armnn::TensorInfo &inputTensorInfo)

static armnn::TensorInfo	OutputShapeOfReshape (const armnn::TensorInfo &inputTensorInfo, const std::vector< int32_t > &targetDimsIn)

static const std::string	GetVersion ()
	Retrieve version in X.Y.Z form. More...

Detailed Description

Definition at line 26 of file TfLiteParser.hpp.

Member Typedef Documentation

◆ BufferPtr

using BufferPtr = std::unique_ptr<tflite::BufferT>

Definition at line 39 of file TfLiteParser.hpp.

◆ BufferRawPtr

using BufferRawPtr = const tflite::BufferT *

Definition at line 40 of file TfLiteParser.hpp.

◆ ModelPtr

using ModelPtr = std::unique_ptr<tflite::ModelT>

Definition at line 30 of file TfLiteParser.hpp.

◆ OperatorCodePtr

using OperatorCodePtr = std::unique_ptr<tflite::OperatorCodeT>

Definition at line 33 of file TfLiteParser.hpp.

◆ OperatorPtr

using OperatorPtr = std::unique_ptr<tflite::OperatorT>

Definition at line 32 of file TfLiteParser.hpp.

◆ SubgraphPtr

using SubgraphPtr = std::unique_ptr<tflite::SubGraphT>

Definition at line 31 of file TfLiteParser.hpp.

◆ TensorIdRawPtr

using TensorIdRawPtr = std::pair<size_t, TensorRawPtr>

Definition at line 37 of file TfLiteParser.hpp.

◆ TensorIdRawPtrVector

using TensorIdRawPtrVector = std::vector<TensorIdRawPtr>

Definition at line 38 of file TfLiteParser.hpp.

◆ TensorPtr

using TensorPtr = std::unique_ptr<tflite::TensorT>

Definition at line 34 of file TfLiteParser.hpp.

◆ TensorRawPtr

using TensorRawPtr = const tflite::TensorT *

Definition at line 35 of file TfLiteParser.hpp.

◆ TensorRawPtrVector

using TensorRawPtrVector = std::vector<TensorRawPtr>

Definition at line 36 of file TfLiteParser.hpp.

Constructor & Destructor Documentation

◆ TfLiteParserImpl()

TfLiteParserImpl ( const armnn::Optional< ITfLiteParser::TfLiteParserOptions > & options = armnn::EmptyOptional() )

Definition at line 740 of file TfLiteParser.cpp.

 : m_Options(options)
 , m_Network(nullptr, nullptr)
 , m_ParserFunctions(tflite::BuiltinOperator_MAX+1, &TfLiteParserImpl::ParseUnsupportedOperator)
 {
     // register supported operators
     m_ParserFunctions[tflite::BuiltinOperator_ABS]                     = &TfLiteParserImpl::ParseAbs;
     m_ParserFunctions[tflite::BuiltinOperator_ADD]                     = &TfLiteParserImpl::ParseAdd;
     m_ParserFunctions[tflite::BuiltinOperator_ARG_MIN]                 = &TfLiteParserImpl::ParseArgMin;
     m_ParserFunctions[tflite::BuiltinOperator_ARG_MAX]                 = &TfLiteParserImpl::ParseArgMax;
     m_ParserFunctions[tflite::BuiltinOperator_AVERAGE_POOL_2D]         = &TfLiteParserImpl::ParseAveragePool2D;
     m_ParserFunctions[tflite::BuiltinOperator_BATCH_TO_SPACE_ND]       = &TfLiteParserImpl::ParseBatchToSpaceND;
     m_ParserFunctions[tflite::BuiltinOperator_BATCH_MATMUL]            = &TfLiteParserImpl::ParseBatchMatMul;
     m_ParserFunctions[tflite::BuiltinOperator_CEIL]                    = &TfLiteParserImpl::ParseCeil;
     m_ParserFunctions[tflite::BuiltinOperator_CAST]                    = &TfLiteParserImpl::ParseCast;
     m_ParserFunctions[tflite::BuiltinOperator_CONCATENATION]           = &TfLiteParserImpl::ParseConcatenation;
     m_ParserFunctions[tflite::BuiltinOperator_CONV_2D]                 = &TfLiteParserImpl::ParseConv2D;
     // Conv3D support was added in TF 2.5, so for backwards compatibility a hash define is needed.
     #if defined(ARMNN_POST_TFLITE_2_4)
     m_ParserFunctions[tflite::BuiltinOperator_CONV_3D]                 = &TfLiteParserImpl::ParseConv3D;
     #endif
     m_ParserFunctions[tflite::BuiltinOperator_CUSTOM]                  = &TfLiteParserImpl::ParseCustomOperator;
     m_ParserFunctions[tflite::BuiltinOperator_DEPTH_TO_SPACE]          = &TfLiteParserImpl::ParseDepthToSpace;
     m_ParserFunctions[tflite::BuiltinOperator_DEPTHWISE_CONV_2D]       = &TfLiteParserImpl::ParseDepthwiseConv2D;
     m_ParserFunctions[tflite::BuiltinOperator_DEQUANTIZE]              = &TfLiteParserImpl::ParseDequantize;
     m_ParserFunctions[tflite::BuiltinOperator_DIV]                     = &TfLiteParserImpl::ParseDiv;
     m_ParserFunctions[tflite::BuiltinOperator_ELU]                     = &TfLiteParserImpl::ParseElu;
     m_ParserFunctions[tflite::BuiltinOperator_EQUAL]                   = &TfLiteParserImpl::ParseEqual;
     m_ParserFunctions[tflite::BuiltinOperator_EXP]                     = &TfLiteParserImpl::ParseExp;
     m_ParserFunctions[tflite::BuiltinOperator_EXPAND_DIMS]             = &TfLiteParserImpl::ParseExpandDims;
     m_ParserFunctions[tflite::BuiltinOperator_FLOOR_DIV]               = &TfLiteParserImpl::ParseFloorDiv;
     m_ParserFunctions[tflite::BuiltinOperator_FULLY_CONNECTED]         = &TfLiteParserImpl::ParseFullyConnected;
     m_ParserFunctions[tflite::BuiltinOperator_GATHER]                  = &TfLiteParserImpl::ParseGather;
     m_ParserFunctions[tflite::BuiltinOperator_GATHER_ND]               = &TfLiteParserImpl::ParseGatherNd;
     m_ParserFunctions[tflite::BuiltinOperator_GREATER]                 = &TfLiteParserImpl::ParseGreater;
     m_ParserFunctions[tflite::BuiltinOperator_GREATER_EQUAL]           = &TfLiteParserImpl::ParseGreaterOrEqual;
     m_ParserFunctions[tflite::BuiltinOperator_HARD_SWISH]              = &TfLiteParserImpl::ParseHardSwish;
     m_ParserFunctions[tflite::BuiltinOperator_LEAKY_RELU]              = &TfLiteParserImpl::ParseLeakyRelu;
     m_ParserFunctions[tflite::BuiltinOperator_LESS]                    = &TfLiteParserImpl::ParseLess;
     m_ParserFunctions[tflite::BuiltinOperator_LESS_EQUAL]              = &TfLiteParserImpl::ParseLessOrEqual;
     m_ParserFunctions[tflite::BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION]
             = &TfLiteParserImpl::ParseLocalResponseNormalization;
     m_ParserFunctions[tflite::BuiltinOperator_LOG]                     = &TfLiteParserImpl::ParseLog;
     m_ParserFunctions[tflite::BuiltinOperator_LOGICAL_NOT]             = &TfLiteParserImpl::ParseLogicalNot;
     m_ParserFunctions[tflite::BuiltinOperator_LOGISTIC]                = &TfLiteParserImpl::ParseLogistic;
     m_ParserFunctions[tflite::BuiltinOperator_LOG_SOFTMAX]             = &TfLiteParserImpl::ParseLogSoftmax;
     m_ParserFunctions[tflite::BuiltinOperator_L2_NORMALIZATION]        = &TfLiteParserImpl::ParseL2Normalization;
     m_ParserFunctions[tflite::BuiltinOperator_MAX_POOL_2D]             = &TfLiteParserImpl::ParseMaxPool2D;
     m_ParserFunctions[tflite::BuiltinOperator_MAXIMUM]                 = &TfLiteParserImpl::ParseMaximum;
     m_ParserFunctions[tflite::BuiltinOperator_MEAN]                    = &TfLiteParserImpl::ParseMean;
     m_ParserFunctions[tflite::BuiltinOperator_MINIMUM]                 = &TfLiteParserImpl::ParseMinimum;
     m_ParserFunctions[tflite::BuiltinOperator_MIRROR_PAD]              = &TfLiteParserImpl::ParseMirrorPad;
     m_ParserFunctions[tflite::BuiltinOperator_MUL]                     = &TfLiteParserImpl::ParseMul;
     m_ParserFunctions[tflite::BuiltinOperator_NEG]                     = &TfLiteParserImpl::ParseNeg;
     m_ParserFunctions[tflite::BuiltinOperator_NOT_EQUAL]               = &TfLiteParserImpl::ParseNotEqual;
     m_ParserFunctions[tflite::BuiltinOperator_PACK]                    = &TfLiteParserImpl::ParsePack;
     m_ParserFunctions[tflite::BuiltinOperator_PAD]                     = &TfLiteParserImpl::ParsePad;
     m_ParserFunctions[tflite::BuiltinOperator_PADV2]                   = &TfLiteParserImpl::ParsePad;
     m_ParserFunctions[tflite::BuiltinOperator_POW]                     = &TfLiteParserImpl::ParsePower;
     m_ParserFunctions[tflite::BuiltinOperator_PRELU]                   = &TfLiteParserImpl::ParsePrelu;
     m_ParserFunctions[tflite::BuiltinOperator_QUANTIZE]                = &TfLiteParserImpl::ParseQuantize;
     m_ParserFunctions[tflite::BuiltinOperator_RELU]                    = &TfLiteParserImpl::ParseRelu;
     m_ParserFunctions[tflite::BuiltinOperator_RELU6]                   = &TfLiteParserImpl::ParseRelu6;
     m_ParserFunctions[tflite::BuiltinOperator_REDUCE_MAX]              = &TfLiteParserImpl::ParseReduceMax;
     m_ParserFunctions[tflite::BuiltinOperator_REDUCE_MIN]              = &TfLiteParserImpl::ParseReduceMin;
     m_ParserFunctions[tflite::BuiltinOperator_REDUCE_PROD]             = &TfLiteParserImpl::ParseReduceProd;
     m_ParserFunctions[tflite::BuiltinOperator_RESHAPE]                 = &TfLiteParserImpl::ParseReshape;
     m_ParserFunctions[tflite::BuiltinOperator_RESIZE_BILINEAR]         = &TfLiteParserImpl::ParseResizeBilinear;
     m_ParserFunctions[tflite::BuiltinOperator_RESIZE_NEAREST_NEIGHBOR] = &TfLiteParserImpl::ParseResizeNearestNeighbor;
     m_ParserFunctions[tflite::BuiltinOperator_REVERSE_V2]              = &TfLiteParserImpl::ParseReverseV2;
     m_ParserFunctions[tflite::BuiltinOperator_RSQRT]                   = &TfLiteParserImpl::ParseRsqrt;
     m_ParserFunctions[tflite::BuiltinOperator_SQRT]                    = &TfLiteParserImpl::ParseSqrt;
     m_ParserFunctions[tflite::BuiltinOperator_SHAPE]                   = &TfLiteParserImpl::ParseShape;
     m_ParserFunctions[tflite::BuiltinOperator_SIN]                     = &TfLiteParserImpl::ParseSin;
     m_ParserFunctions[tflite::BuiltinOperator_SLICE]                   = &TfLiteParserImpl::ParseSlice;
     m_ParserFunctions[tflite::BuiltinOperator_SOFTMAX]                 = &TfLiteParserImpl::ParseSoftmax;
     m_ParserFunctions[tflite::BuiltinOperator_SPACE_TO_BATCH_ND]       = &TfLiteParserImpl::ParseSpaceToBatchND;
     m_ParserFunctions[tflite::BuiltinOperator_SPACE_TO_DEPTH]          = &TfLiteParserImpl::ParseSpaceToDepth;
     m_ParserFunctions[tflite::BuiltinOperator_SPLIT]                   = &TfLiteParserImpl::ParseSplit;
     m_ParserFunctions[tflite::BuiltinOperator_SPLIT_V]                 = &TfLiteParserImpl::ParseSplitV;
     m_ParserFunctions[tflite::BuiltinOperator_SQUEEZE]                 = &TfLiteParserImpl::ParseSqueeze;
     m_ParserFunctions[tflite::BuiltinOperator_SQUARE]                  = &TfLiteParserImpl::ParseSquare;
     m_ParserFunctions[tflite::BuiltinOperator_SQUARED_DIFFERENCE]      = &TfLiteParserImpl::ParseSquaredDifference;
     m_ParserFunctions[tflite::BuiltinOperator_STRIDED_SLICE]           = &TfLiteParserImpl::ParseStridedSlice;
     m_ParserFunctions[tflite::BuiltinOperator_SUB]                     = &TfLiteParserImpl::ParseSub;
     m_ParserFunctions[tflite::BuiltinOperator_SUM]                     = &TfLiteParserImpl::ParseSum;
     m_ParserFunctions[tflite::BuiltinOperator_TANH]                    = &TfLiteParserImpl::ParseTanH;
     m_ParserFunctions[tflite::BuiltinOperator_TILE]                    = &TfLiteParserImpl::ParseTile;
     m_ParserFunctions[tflite::BuiltinOperator_TRANSPOSE]               = &TfLiteParserImpl::ParseTranspose;
     m_ParserFunctions[tflite::BuiltinOperator_TRANSPOSE_CONV]          = &TfLiteParserImpl::ParseTransposeConv;
     m_ParserFunctions[tflite::BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM]
             = &TfLiteParserImpl::ParseUnidirectionalSequenceLSTM;
     m_ParserFunctions[tflite::BuiltinOperator_UNPACK]                  = &TfLiteParserImpl::ParseUnpack;
  
     // register supported custom operators
     m_CustomParserFunctions["TFLite_Detection_PostProcess"]      = &TfLiteParserImpl::ParseDetectionPostProcess;
 }

◆ ~TfLiteParserImpl()

~TfLiteParserImpl ( )

default

Member Function Documentation

◆ CreateNetworkFromBinary()

INetworkPtr CreateNetworkFromBinary ( const std::vector< uint8_t > & binaryContent )

Create the network from a flatbuffers binary.

Definition at line 957 of file TfLiteParser.cpp.

 {
     ResetParser();
     m_Model = LoadModelFromBinary(binaryContent.data(), binaryContent.size());
     return CreateNetworkFromModel();
 }

References TfLiteParserImpl::LoadModelFromBinary().

◆ CreateNetworkFromBinaryAsDynamic()

armnn::INetworkPtr CreateNetworkFromBinaryAsDynamic ( const std::vector< uint8_t > & binaryContent )

◆ CreateNetworkFromBinaryFile()

INetworkPtr CreateNetworkFromBinaryFile ( const char * graphFile )

Create the network from a flatbuffers binary file on disk.

Definition at line 950 of file TfLiteParser.cpp.

 {
     ResetParser();
     m_Model = LoadModelFromFile(graphFile);
     return CreateNetworkFromModel();
 }

References TfLiteParserImpl::LoadModelFromFile().

◆ GetBuffer()

TfLiteParserImpl::BufferRawPtr GetBuffer	(	const ModelPtr &	model,
		size_t	bufferIndex
	)

static

Definition at line 5616 of file TfLiteParser.cpp.

 {
     CHECK_BUFFER(model, bufferIndex);
     return model->buffers[bufferIndex].get();
 }

References CHECK_BUFFER.

◆ GetInputs()

TfLiteParserImpl::TensorRawPtrVector GetInputs	(	const ModelPtr &	model,
		size_t	subgraphIndex,
		size_t	operatorIndex
	)

static

Definition at line 5304 of file TfLiteParser.cpp.

 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
  
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
     const auto& operatorPtr = subgraphPtr->operators[operatorIndex];
  
     size_t inputCount = operatorPtr->inputs.size();
     TensorRawPtrVector result;
     for (size_t i = 0; i < inputCount; ++i)
     {
         // If the input location is -1 then assume input is turned off.
         if (operatorPtr->inputs[i] == -1)
         {
             continue;
         }
         else
         {
             uint32_t inputId = CHECKED_NON_NEGATIVE(operatorPtr->inputs[i]);
             result.push_back(subgraphPtr->tensors[inputId].get());
         }
     }
     return result;
 }

References CHECK_MODEL, and CHECKED_NON_NEGATIVE.

◆ GetInputTensorIds()

std::vector< int32_t > & GetInputTensorIds	(	const ModelPtr &	model,
		size_t	subgraphIndex,
		size_t	operatorIndex
	)

static

Definition at line 5384 of file TfLiteParser.cpp.

 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
     const auto& operatorPtr = subgraphPtr->operators[operatorIndex];
     return operatorPtr->inputs;
 }

References CHECK_MODEL.

◆ GetNetworkInputBindingInfo()

BindingPointInfo GetNetworkInputBindingInfo	(	size_t	subgraphId,
		const std::string &	name
	)		const

Retrieve binding info (layer id and tensor info) for the network input identified by the given layer name and subgraph id.

Definition at line 5794 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(m_Model, subgraphId);
     auto inputs = GetSubgraphInputs(m_Model, subgraphId);
     for (auto const& input : inputs)
     {
         if (input.second->name == name)
         {
             auto bindingId = GenerateLayerBindingId(subgraphId, input.first);
             auto inputTensorInfo = ToTensorInfo(input.second);
             // Input tensors are always treated as constant tensors during network execution.
             inputTensorInfo.SetConstant(true);
             return std::make_pair(bindingId, inputTensorInfo);
         }
     }
  
     std::stringstream bindings;
     for (auto const& input : inputs)
     {
         bindings << "'" << input.second->name << "' ";
     }
  
     throw ParseException(
         fmt::format("No input binding found for subgraph:{} and name:{}. "
                     "Possible inputs are: [{}] {}",
                     subgraphId,
                     name,
                     bindings.str(),
                     CHECK_LOCATION().AsString()));
 }

References CHECK_LOCATION, CHECK_SUBGRAPH, TfLiteParserImpl::GetSubgraphInputs(), TensorInfo::SetConstant(), and armnnDeserializer::ToTensorInfo().

◆ GetNetworkOutputBindingInfo()

BindingPointInfo GetNetworkOutputBindingInfo	(	size_t	subgraphId,
		const std::string &	name
	)		const

Retrieve binding info (layer id and tensor info) for the network output identified by the given layer name and subgraph id.

Definition at line 5826 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(m_Model, subgraphId);
     auto outputs = GetSubgraphOutputs(m_Model, subgraphId);
     for (unsigned int i = 0; i < outputs.size(); ++i)
     {
         auto const output = outputs[i];
         if (output.second->name == name)
         {
             auto bindingId = GenerateLayerBindingId(subgraphId, output.first);
             std::vector<unsigned int> shape = m_OverriddenOutputShapes.size() > 0 ?
                                                 m_OverriddenOutputShapes[i] : AsUnsignedVector(output.second->shape);
             return std::make_pair(bindingId, ToTensorInfo(output.second, shape));
         }
     }
  
     std::stringstream bindings;
     for (auto const& output : outputs)
     {
         bindings << "'" << output.second->name << "' ";
     }
  
     throw ParseException(
         fmt::format("No output binding found for subgraph:{} and name:{}. "
                     "Possible outputs are: [{}] {}",
                     subgraphId,
                     name,
                     bindings.str(),
                     CHECK_LOCATION().AsString()));
 }

References CHECK_LOCATION, CHECK_SUBGRAPH, TfLiteParserImpl::GetSubgraphOutputs(), and armnnDeserializer::ToTensorInfo().

◆ GetOutputs()

TfLiteParserImpl::TensorRawPtrVector GetOutputs	(	const ModelPtr &	model,
		size_t	subgraphIndex,
		size_t	operatorIndex
	)

static

Definition at line 5331 of file TfLiteParser.cpp.

 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
  
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
     const auto& operatorPtr = subgraphPtr->operators[operatorIndex];
  
     size_t outputCount = operatorPtr->outputs.size();
     TensorRawPtrVector result(outputCount);
     for (size_t i = 0; i < outputCount; ++i)
     {
         uint32_t outputId = CHECKED_NON_NEGATIVE(operatorPtr->outputs[i]);
         CHECK_TENSOR(model, subgraphIndex, outputId);
         result[i] = subgraphPtr->tensors[outputId].get();
     }
     return result;
 }

References CHECK_MODEL, CHECK_TENSOR, and CHECKED_NON_NEGATIVE.

◆ GetOutputTensorIds()

std::vector< int32_t > & GetOutputTensorIds	(	const ModelPtr &	model,
		size_t	subgraphIndex,
		size_t	operatorIndex
	)

static

Definition at line 5394 of file TfLiteParser.cpp.

 {
     CHECK_MODEL(model, subgraphIndex, operatorIndex);
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
     const auto& operatorPtr = subgraphPtr->operators[operatorIndex];
     return operatorPtr->outputs;
 }

References CHECK_MODEL.

◆ GetSubgraphCount()

size_t GetSubgraphCount ( ) const

Return the number of subgraphs in the parsed model.

Definition at line 5858 of file TfLiteParser.cpp.

 {
     return m_Model->subgraphs.size();
 }

◆ GetSubgraphInputs()

TfLiteParserImpl::TensorIdRawPtrVector GetSubgraphInputs	(	const ModelPtr &	model,
		size_t	subgraphIndex
	)

static

Definition at line 5351 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(model, subgraphIndex);
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
  
     size_t inputCount = subgraphPtr->inputs.size();
     TensorIdRawPtrVector result(inputCount);
     for (size_t i = 0; i < inputCount; ++i)
     {
         uint32_t inputId = CHECKED_NON_NEGATIVE(subgraphPtr->inputs[i]);
         CHECK_TENSOR(model, subgraphIndex, inputId);
         result[i] = std::make_pair(inputId, subgraphPtr->tensors[inputId].get());
     }
     return result;
 }

References CHECK_SUBGRAPH, CHECK_TENSOR, and CHECKED_NON_NEGATIVE.

Referenced by TfLiteParserImpl::GetNetworkInputBindingInfo(), and TfLiteParserImpl::GetSubgraphInputTensorNames().

◆ GetSubgraphInputTensorNames()

std::vector< std::string > GetSubgraphInputTensorNames ( size_t subgraphId ) const

Return the input tensor names for a given subgraph.

Definition at line 5863 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(m_Model, subgraphId);
     auto inputs = GetSubgraphInputs(m_Model, subgraphId);
     std::vector<std::string> result;
     result.reserve(inputs.size());
     for (auto const& input : inputs)
     {
         result.push_back(input.second->name);
     }
     return result;
 }

References CHECK_SUBGRAPH, and TfLiteParserImpl::GetSubgraphInputs().

◆ GetSubgraphOutputs()

TfLiteParserImpl::TensorIdRawPtrVector GetSubgraphOutputs	(	const ModelPtr &	model,
		size_t	subgraphIndex
	)

static

Definition at line 5368 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(model, subgraphIndex);
     const auto& subgraphPtr = model->subgraphs[subgraphIndex];
  
     size_t outputCount = subgraphPtr->outputs.size();
     TensorIdRawPtrVector result(outputCount);
     for (size_t i = 0; i < outputCount; ++i)
     {
         uint32_t outputId = CHECKED_NON_NEGATIVE(subgraphPtr->outputs[i]);
         result[i] = std::make_pair(outputId, subgraphPtr->tensors[outputId].get());
     }
     return result;
 }

References CHECK_SUBGRAPH, and CHECKED_NON_NEGATIVE.

Referenced by TfLiteParserImpl::GetNetworkOutputBindingInfo(), and TfLiteParserImpl::GetSubgraphOutputTensorNames().

◆ GetSubgraphOutputTensorNames()

std::vector< std::string > GetSubgraphOutputTensorNames ( size_t subgraphId ) const

Return the output tensor names for a given subgraph.

Definition at line 5876 of file TfLiteParser.cpp.

 {
     CHECK_SUBGRAPH(m_Model, subgraphId);
     auto outputs = GetSubgraphOutputs(m_Model, subgraphId);
     std::vector<std::string> result;
     result.reserve(outputs.size());
     for (auto const& output : outputs)
     {
         result.push_back(output.second->name);
     }
     return result;
 }

References CHECK_SUBGRAPH, and TfLiteParserImpl::GetSubgraphOutputs().

◆ GetVersion()

const std::string GetVersion ( )

static

Retrieve version in X.Y.Z form.

Definition at line 5889 of file TfLiteParser.cpp.

 {
     return TFLITE_PARSER_VERSION;
 }

References TFLITE_PARSER_VERSION.

◆ LoadModel()

armnn::INetworkPtr LoadModel ( std::unique_ptr< tflite::ModelT > model )

Definition at line 965 of file TfLiteParser.cpp.

 {
     ResetParser();
     m_Model = std::move(model);
  
     return CreateNetworkFromModel();
 }

◆ LoadModelFromBinary()

TfLiteParserImpl::ModelPtr LoadModelFromBinary	(	const uint8_t *	binaryContent,
		size_t	len
	)

static

Definition at line 5285 of file TfLiteParser.cpp.

 {
     if (binaryContent == nullptr)
      {
         throw InvalidArgumentException(fmt::format("Invalid (null) binary content {}",
                                        CHECK_LOCATION().AsString()));
      }
     flatbuffers::Verifier verifier(binaryContent, len);
     if (verifier.VerifyBuffer<tflite::Model>() == false)
     {
         throw ParseException(
             fmt::format("Buffer doesn't conform to the expected Tensorflow Lite "
                         "flatbuffers format. size:{} {}",
                         len,
                         CHECK_LOCATION().AsString()));
     }
     return tflite::UnPackModel(binaryContent);
 }

References CHECK_LOCATION.

Referenced by TfLiteParserImpl::CreateNetworkFromBinary(), and TfLiteParserImpl::LoadModelFromFile().

◆ LoadModelFromFile()

TfLiteParserImpl::ModelPtr LoadModelFromFile ( const char * fileName )

static

Definition at line 5255 of file TfLiteParser.cpp.

 {
     if (fileName == nullptr)
     {
         throw InvalidArgumentException(fmt::format("Invalid (null) file name {}",
                                        CHECK_LOCATION().AsString()));
     }
     std::error_code errorCode;
     fs::path pathToFile(fileName);
     if (!fs::exists(pathToFile, errorCode))
     {
         //fmt::format() could not be used here (format error)
         std::stringstream msg;
         msg << "Cannot find the file (" << fileName << ") errorCode: " << errorCode
             << " " << CHECK_LOCATION().AsString();
         throw FileNotFoundException(msg.str());
     }
     if (!fs::is_regular_file(pathToFile))
     {
         // Exclude non regular files.
         throw InvalidArgumentException(fmt::format("File \"{}\" is not a regular file and cannot be loaded.",
                                                    pathToFile.c_str()));
     }
  
     std::ifstream file(fileName, std::ios::binary);
     std::string fileContent((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
     return LoadModelFromBinary(reinterpret_cast<const uint8_t *>(fileContent.c_str()),
                                fileContent.size());
 }

References CHECK_LOCATION, and TfLiteParserImpl::LoadModelFromBinary().

Referenced by TfLiteParserImpl::CreateNetworkFromBinaryFile().

◆ OutputShapeOfReshape()

armnn::TensorInfo OutputShapeOfReshape	(	const armnn::TensorInfo &	inputTensorInfo,
		const std::vector< int32_t > &	targetDimsIn
	)

static

Definition at line 3183 of file TfLiteParser.cpp.

 {
     std::vector<unsigned int> outputDims(targetDimsIn.begin(), targetDimsIn.end());
     const auto stretchDim = std::find(targetDimsIn.begin(), targetDimsIn.end(), -1);
  
     if (stretchDim != targetDimsIn.end())
     {
         if (std::find(std::next(stretchDim), targetDimsIn.end(), -1) != targetDimsIn.end())
         {
             throw ParseException(
                 fmt::format("At most one component of shape can be -1 {}", CHECK_LOCATION().AsString()));
         }
  
         auto targetNumElements =
             armnn::numeric_cast<unsigned int>(
                 std::accumulate(targetDimsIn.begin(), targetDimsIn.end(), -1, std::multiplies<int32_t>()));
  
         auto stretchIndex = static_cast<size_t>(std::distance(targetDimsIn.begin(), stretchDim));
         outputDims[stretchIndex] = inputTensorInfo.GetNumElements() / targetNumElements;
     }
  
     TensorShape outputShape = TensorShape(static_cast<unsigned int>(outputDims.size()), outputDims.data());
  
     TensorInfo reshapeInfo = inputTensorInfo;
     reshapeInfo.SetShape(outputShape);
  
     return reshapeInfo;
 }

References CHECK_LOCATION, TensorInfo::GetNumElements(), and TensorInfo::SetShape().

◆ OutputShapeOfSqueeze()

armnn::TensorInfo OutputShapeOfSqueeze	(	std::vector< uint32_t >	squeezeDims,
		const armnn::TensorInfo &	inputTensorInfo
	)

static

Definition at line 2312 of file TfLiteParser.cpp.

 {
     CHECK_VALID_SIZE(squeezeDims.size(), 0, 1, 2, 3, 4);
     static const uint32_t dimensionSequence[] = { 0, 1, 2, 3 };
  
     if (inputTensorInfo.GetNumDimensions() > 4)
     {
         std::stringstream ss;
         ss << "Input tensor has unexpected number of dimensions:" << inputTensorInfo.GetNumDimensions()
            << " shape:" << inputTensorInfo.GetShape() << " "
            << CHECK_LOCATION().AsString();
         throw ParseException(ss.str());
     }
  
     if (squeezeDims.empty())
     {
         squeezeDims.assign(dimensionSequence,
                            dimensionSequence+inputTensorInfo.GetNumDimensions());
     }
  
     std::vector<uint32_t> outputDims;
     for(unsigned int i = 0; i < inputTensorInfo.GetNumDimensions(); i++)
     {
         bool skipSqueeze = (std::find(squeezeDims.begin(), squeezeDims.end(), i) == squeezeDims.end());
         auto currentDimension = inputTensorInfo.GetShape()[i];
         if (skipSqueeze || currentDimension != 1)
         {
             outputDims.push_back(currentDimension);
         }
     }
  
     if (outputDims.size() > 4)
     {
         std::stringstream ss;
         ss << "Output tensor has unexpected number of dimensions:" << inputTensorInfo.GetNumDimensions()
            << " shape:" << inputTensorInfo.GetShape() << " "
            << CHECK_LOCATION().AsString();
         throw ParseException(ss.str());
     }
  
     TensorShape outShape = TensorShape(static_cast<unsigned int>(outputDims.size()),
                                        outputDims.data());
  
     // we need to preserve the tensor type and the quantization data as well
     TensorInfo outTensorInfo = inputTensorInfo;
     outTensorInfo.SetShape(outShape);
  
     return outTensorInfo;
 }

References CHECK_LOCATION, CHECK_VALID_SIZE, TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), and TensorInfo::SetShape().

The documentation for this class was generated from the following files:

src/armnnTfLiteParser/TfLiteParser.hpp
src/armnnTfLiteParser/TfLiteParser.cpp

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

◆ BufferPtr

◆ BufferRawPtr

◆ ModelPtr

◆ OperatorCodePtr

◆ OperatorPtr

◆ SubgraphPtr

◆ TensorIdRawPtr

◆ TensorIdRawPtrVector

◆ TensorPtr

◆ TensorRawPtr

◆ TensorRawPtrVector

Constructor & Destructor Documentation

◆ TfLiteParserImpl()

◆ ~TfLiteParserImpl()

Member Function Documentation

◆ CreateNetworkFromBinary()

◆ CreateNetworkFromBinaryAsDynamic()

◆ CreateNetworkFromBinaryFile()

◆ GetBuffer()

◆ GetInputs()

◆ GetInputTensorIds()

◆ GetNetworkInputBindingInfo()

◆ GetNetworkOutputBindingInfo()

◆ GetOutputs()

◆ GetOutputTensorIds()

◆ GetSubgraphCount()

◆ GetSubgraphInputs()

◆ GetSubgraphInputTensorNames()

◆ GetSubgraphOutputs()

◆ GetSubgraphOutputTensorNames()

◆ GetVersion()

◆ LoadModel()

◆ LoadModelFromBinary()

◆ LoadModelFromFile()

◆ OutputShapeOfReshape()

◆ OutputShapeOfSqueeze()