#include <RecordByRecordCaffeParser.hpp>

Inheritance diagram for RecordByRecordCaffeParser:

Public Member Functions
virtual armnn::INetworkPtr	CreateNetworkFromBinaryFile (const char *graphFile, const std::map< std::string, armnn::TensorShape > &inputShapes, const std::vector< std::string > &requestedOutputs) override
	Create the network from a protobuf binary file on disk. More...

	RecordByRecordCaffeParser ()

Public Member Functions inherited from CaffeParserBase
virtual armnn::INetworkPtr	CreateNetworkFromTextFile (const char *graphFile, const std::map< std::string, armnn::TensorShape > &inputShapes, const std::vector< std::string > &requestedOutputs) override
	Create the network from a protobuf text file on disk. More...

virtual armnn::INetworkPtr	CreateNetworkFromString (const char *protoText, const std::map< std::string, armnn::TensorShape > &inputShapes, const std::vector< std::string > &requestedOutputs) override
	Creates the network directly from protobuf text in a string. Useful for debugging/testing. More...

virtual BindingPointInfo	GetNetworkInputBindingInfo (const std::string &name) const override
	Retrieves binding info (layer id and tensor info) for the network input identified by the given layer name. More...

virtual BindingPointInfo	GetNetworkOutputBindingInfo (const std::string &name) const override
	Retrieves binding info (layer id and tensor info) for the network output identified by the given layer name. More...

	CaffeParserBase ()

Additional Inherited Members
Static Public Member Functions inherited from ICaffeParser
static ICaffeParser *	CreateRaw ()

static ICaffeParserPtr	Create ()

static void	Destroy (ICaffeParser *parser)

Protected Types inherited from CaffeParserBase
using	OperationParsingFunction = void(CaffeParserBase::*)(const caffe::LayerParameter &layerParam)

Protected Member Functions inherited from CaffeParserBase
armnn::TensorInfo	BlobShapeToTensorInfo (const caffe::BlobShape &blobShape) const
	Converts Caffe's protobuf tensor shape format to ArmNN's. More...

void	TrackInputBinding (armnn::IConnectableLayer *layer, armnn::LayerBindingId id, const armnn::TensorInfo &tensorInfo)

void	TrackOutputBinding (armnn::IConnectableLayer *layer, armnn::LayerBindingId id, const armnn::TensorInfo &tensorInfo)

void	SetArmnnOutputSlotForCaffeTop (const std::string &caffeTopName, armnn::IOutputSlot &armnnOutputSlot)

armnn::IOutputSlot &	GetArmnnOutputSlotForCaffeTop (const std::string &caffeTopName) const
	Retrieves the Armnn IOutputSlot representing the given Caffe top. More...

void	Cleanup ()

armnn::INetworkPtr	CreateNetworkFromNetParameter (caffe::NetParameter &netParam, const std::map< std::string, armnn::TensorShape > &inputShapes, const std::vector< std::string > &requestedOutputs)
	Parses a NetParameter loaded into memory from one of the other CreateNetwork*. More...

void	LoadNetParam (caffe::NetParameter &netParameter)
	does the actual conversion from caffe::NetParameter to armnn::INetwork More...

std::vector< const caffe::LayerParameter * >	GetInputs (const caffe::LayerParameter &layerParam)
	Find the Caffe layers listed as inputs (bottoms) for a given layer. More...

void	ResolveInPlaceLayers (caffe::NetParameter &netParameter)
	Modifies the Caffe network to replace "in-place" layers (whose top() and bottom() are both the same) with regular layers. More...

void	ParseInputLayer (const caffe::LayerParameter &layerParam)
	Adds an armnn layer to m_Network given a Caffe LayerParameter of the correct type and is responsible for recording any newly created IOutputSlots using SetArmnnOutputSlotForCaffeTop(). More...

void	ParseConvLayer (const caffe::LayerParameter &layerParam)

void	ParsePoolingLayer (const caffe::LayerParameter &layerParam)

void	ParseReluLayer (const caffe::LayerParameter &layerParam)

void	ParseLRNLayer (const caffe::LayerParameter &layerParam)

void	ParseInnerProductLayer (const caffe::LayerParameter &layerParam)

void	ParseSoftmaxLayer (const caffe::LayerParameter &layerParam)

void	ParseEltwiseLayer (const caffe::LayerParameter &layerParam)

void	ParseConcatLayer (const caffe::LayerParameter &layerParam)

void	ParseBatchNormLayer (const caffe::LayerParameter &layerParam)

void	ParseScaleLayer (const caffe::LayerParameter &layerParam)

void	ParseSplitLayer (const caffe::LayerParameter &layerParam)

void	ParseDropoutLayer (const caffe::LayerParameter &layerParam)

void	AddConvLayerWithSplits (const caffe::LayerParameter &layerParam, const armnn::Convolution2dDescriptor &desc, unsigned int kernelW, unsigned int kernelH)
	ParseConv may use these helpers depending on the group parameter. More...

void	AddConvLayerWithDepthwiseConv (const caffe::LayerParameter &layerParam, const armnn::Convolution2dDescriptor &desc, unsigned int kernelW, unsigned int kernelH)

Protected Member Functions inherited from ICaffeParser
virtual	~ICaffeParser ()

Static Protected Member Functions inherited from CaffeParserBase
static void	TrackBindingPoint (armnn::IConnectableLayer layer, armnn::LayerBindingId id, const armnn::TensorInfo &tensorInfo, const char bindingPointDesc, std::unordered_map< std::string, BindingPointInfo > &nameToBindingInfo)

static std::pair< armnn::LayerBindingId, armnn::TensorInfo >	GetBindingInfo (const std::string &layerName, const char *bindingPointDesc, const std::unordered_map< std::string, BindingPointInfo > &bindingInfos)

Protected Attributes inherited from CaffeParserBase
std::unordered_map< std::string, BindingPointInfo >	m_NetworkInputsBindingInfo
	maps input layer names to their corresponding ids and tensor infos More...

std::unordered_map< std::string, BindingPointInfo >	m_NetworkOutputsBindingInfo
	maps output layer names to their corresponding ids and tensor infos More...

armnn::INetworkPtr	m_Network

std::map< std::string, armnn::TensorShape >	m_InputShapes

std::unordered_map< std::string, armnn::IOutputSlot * >	m_ArmnnOutputSlotForCaffeTop
	As we add armnn layers we store the armnn IOutputSlot which corresponds to the Caffe tops. More...

std::vector< std::string >	m_RequestedOutputs

std::map< std::string, const caffe::LayerParameter * >	m_CaffeLayersByTopName

Static Protected Attributes inherited from CaffeParserBase
static const std::map< std::string, OperationParsingFunction >	ms_CaffeLayerNameToParsingFunctions
	Maps Caffe layer names to parsing member functions. More...

Detailed Description

Definition at line 25 of file RecordByRecordCaffeParser.hpp.

Constructor & Destructor Documentation

◆ RecordByRecordCaffeParser()

RecordByRecordCaffeParser ( )

Definition at line 461 of file RecordByRecordCaffeParser.cpp.

461 : CaffeParserBase()

462 {}

armnnCaffeParser::CaffeParserBase::CaffeParserBase

CaffeParserBase()

Definition: CaffeParser.cpp:274

Member Function Documentation

◆ CreateNetworkFromBinaryFile()

armnn::INetworkPtr CreateNetworkFromBinaryFile	(	const char *	graphFile,
		const std::map< std::string, armnn::TensorShape > &	inputShapes,
		const std::vector< std::string > &	requestedOutputs
	)

overridevirtual

Create the network from a protobuf binary file on disk.

Implements ICaffeParser.

Definition at line 464 of file RecordByRecordCaffeParser.cpp.

References CaffeParserBase::Cleanup(), IOutputSlot::Connect(), INetwork::Create(), CaffeParserBase::GetArmnnOutputSlotForCaffeTop(), armnn::info, CaffeParserBase::m_InputShapes, CaffeParserBase::m_Network, CaffeParserBase::m_NetworkInputsBindingInfo, CaffeParserBase::m_NetworkOutputsBindingInfo, CaffeParserBase::ms_CaffeLayerNameToParsingFunctions, armnn::numeric_cast(), CaffeParserBase::ResolveInPlaceLayers(), and CaffeParserBase::TrackOutputBinding().

 {
 
     m_InputShapes = inputShapes;
     if (requestedOutputs.size() == 0)
     {
         throw armnn::ParseException("requestedOutputs must have at least one entry");
     }
     m_RequestedOutputs = requestedOutputs;
 
     std::ifstream ifs(graphFile, std::ifstream::in|std::ifstream::binary);
     if (ifs.fail())
     {
         throw armnn::FileNotFoundException("Failed to open graph file '" + std::string(graphFile) + "'");
     }
 
     std::vector<LayerParameterInfo> layerInfo;
     NetParameterInfo netParameterInfo;
     while(true)
     {
         ProtobufFieldInfo fieldInfo = readFieldInfo(ifs);
         if (fieldInfo.eof())
         {
             break;
         }
         switch(fieldInfo.field_type())
         {
             case 0:
             {
                 ReadBase128(ifs);
                 break;
             }
             case 2:
             {
                 // The values of interest from the caffe.proto schema are:
                 // optional string name = 1; // consider giving the network a name
                 // DEPRECATED. See InputParameter. The input blobs to the network.
                 // repeated string input = 3;
                 // DEPRECATED. See InputParameter. The shape of the input blobs.
                 // repeated BlobShape input_shape = 8;
 
                 // 4D input dimensions -- deprecated.  Use "input_shape" instead.
                 // If specified, for each input blob there should be four
                 // values specifying the num, channels, height and width of the input blob.
                 // Thus, there should be a total of (4 * #input) numbers.
                 // repeated int32 input_dim = 4;
 
                 // The layers that make up the net.  Each of their configurations, including
                 // connectivity and behavior, is specified as a LayerParameter.
                 // repeated LayerParameter layer = 100;  // ID 100 so layers are printed last.
 
                 // The first four will (if present) be read into the NetParameterInfo
                 // the LayerParameters will be read into the LayerParameterInfo vector.
 
                 int size = ReadBase128(ifs);
                 std::streamoff posStartOfData = ifs.tellg();
                 ifs.seekg(size, std::ios_base::cur);
                 if(!ifs.good())
                 {
                     throw armnn::ParseException("failed to seek ahead in binary caffe file");
                 }
                 std::streamoff endOfLayer = ifs.tellg();
                 if (fieldInfo.field_id() == 1)
                 {
                     VarLenDataInfo dataInfo = CreateVarLenDataInfo(posStartOfData, endOfLayer);
                     auto graphName = AllocateBuffer(ifs, dataInfo);
                     netParameterInfo.set_name(graphName, dataInfo.SizeOfData());
                 }
                 if (fieldInfo.field_id() == 3)
                 {
                     VarLenDataInfo dataInfo = CreateVarLenDataInfo(posStartOfData, endOfLayer);
                     auto inputName = AllocateBuffer(ifs, dataInfo);
                     netParameterInfo.add_input(inputName, dataInfo.SizeOfData());
                 }
                 if (fieldInfo.field_id() == 8)
                 {
                     VarLenDataInfo dataInfo = CreateVarLenDataInfo(posStartOfData, endOfLayer);
                     auto inputShape = AllocateBuffer(ifs, dataInfo);
                     caffe::BlobShape blobShape;
                     bool bRet = blobShape.ParseFromArray(inputShape.get(), static_cast<int>(dataInfo.SizeOfData()));
                     if (!bRet)
                     {
                         throw armnn::ParseException("Failed to parse input shape");
                     }
                     netParameterInfo.add_blob_shape(blobShape);
                 }
                 if (fieldInfo.field_id() == 4)
                 {
                     int input_dim = ReadBase128(ifs);
                     netParameterInfo.add_input_dimension(input_dim);
                 }
                 if (fieldInfo.field_id() == 100)
                 {
                     LayerParameterInfo info(CreateVarLenDataInfo(posStartOfData, endOfLayer));
                     ReadTopologicalInfoForLayerParameter(info, ifs);
                     layerInfo.push_back(info);
                 }
                 break;
             }
             default:
             {
                 break;
             }
         }
     }
     std::vector<const LayerParameterInfo*> sortedNodes;
     ProcessLayers(netParameterInfo, layerInfo, m_RequestedOutputs, sortedNodes);
     armnn::INetworkPtr networkPtr = LoadLayers(ifs, sortedNodes, netParameterInfo);
     return networkPtr;
 
 }

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

src/armnnCaffeParser/RecordByRecordCaffeParser.hpp
src/armnnCaffeParser/RecordByRecordCaffeParser.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RecordByRecordCaffeParser()

Member Function Documentation

◆ CreateNetworkFromBinaryFile()