SerializerVisitor Class Reference

#include <Serializer.hpp>

Inheritance diagram for SerializerVisitor:

Public Member Functions
	SerializerVisitor ()
	~SerializerVisitor ()
flatbuffers::FlatBufferBuilder &	GetFlatBufferBuilder ()
std::vector< int > &	GetInputIds ()
std::vector< int > &	GetOutputIds ()
std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > &	GetSerializedLayers ()
flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions >	GetVersionTable ()
void	VisitAbsLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function an absolute layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitActivationLayer (const armnn::IConnectableLayer *layer, const armnn::ActivationDescriptor &descriptor, const char *name=nullptr) override
	Function that an activation layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitAdditionLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function that an addition layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitArgMinMaxLayer (const armnn::IConnectableLayer *layer, const armnn::ArgMinMaxDescriptor &argMinMaxDescriptor, const char *name=nullptr) override
	Function that an arg min max layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitBatchToSpaceNdLayer (const armnn::IConnectableLayer *layer, const armnn::BatchToSpaceNdDescriptor &descriptor, const char *name=nullptr) override
	Function that a batch to space ND layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitBatchNormalizationLayer (const armnn::IConnectableLayer *layer, const armnn::BatchNormalizationDescriptor &BatchNormalizationDescriptor, const armnn::ConstTensor &mean, const armnn::ConstTensor &variance, const armnn::ConstTensor &beta, const armnn::ConstTensor &gamma, const char *name=nullptr) override
	Function that a batch normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitComparisonLayer (const armnn::IConnectableLayer *layer, const armnn::ComparisonDescriptor &descriptor, const char *name=nullptr) override
	Function a Comparison layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitConcatLayer (const armnn::IConnectableLayer *layer, const armnn::ConcatDescriptor &concatDescriptor, const char *name=nullptr) override
	Function that a concat layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitConstantLayer (const armnn::IConnectableLayer *layer, const armnn::ConstTensor &input, const char *=nullptr) override
	Function a layer with no inputs and a single output, which always corresponds to the passed in constant tensor should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitConvolution2dLayer (const armnn::IConnectableLayer *layer, const armnn::Convolution2dDescriptor &descriptor, const armnn::ConstTensor &weights, const armnn::Optional< armnn::ConstTensor > &biases, const char *=nullptr) override
	Function that a 2D convolution layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitDepthToSpaceLayer (const armnn::IConnectableLayer *layer, const armnn::DepthToSpaceDescriptor &descriptor, const char *name=nullptr) override
	Function a depth to space layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitDepthwiseConvolution2dLayer (const armnn::IConnectableLayer *layer, const armnn::DepthwiseConvolution2dDescriptor &descriptor, const armnn::ConstTensor &weights, const armnn::Optional< armnn::ConstTensor > &biases, const char *name=nullptr) override
	Function that a 2D depthwise convolution layer with biases should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitDequantizeLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function that a Dequantize layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitDetectionPostProcessLayer (const armnn::IConnectableLayer *layer, const armnn::DetectionPostProcessDescriptor &descriptor, const armnn::ConstTensor &anchors, const char *name=nullptr) override
	Function that a Detection PostProcess layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitDivisionLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a division layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitElementwiseUnaryLayer (const armnn::IConnectableLayer *layer, const armnn::ElementwiseUnaryDescriptor &descriptor, const char *name=nullptr) override
	Function a ElementwiseUnary layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitEqualLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function an Equal layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitFloorLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a floor layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitFullyConnectedLayer (const armnn::IConnectableLayer *layer, const armnn::FullyConnectedDescriptor &fullyConnectedDescriptor, const armnn::ConstTensor &weights, const armnn::Optional< armnn::ConstTensor > &biases, const char *name=nullptr) override
	Function that a fully connected layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitGatherLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a Gather layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitGreaterLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a Greater layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitInputLayer (const armnn::IConnectableLayer *layer, armnn::LayerBindingId id, const char *name=nullptr) override
	Function that an InputLayer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitInstanceNormalizationLayer (const armnn::IConnectableLayer *layer, const armnn::InstanceNormalizationDescriptor &instanceNormalizationDescriptor, const char *name=nullptr) override
	Function that an instance normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitL2NormalizationLayer (const armnn::IConnectableLayer *layer, const armnn::L2NormalizationDescriptor &l2NormalizationDescriptor, const char *name=nullptr) override
	Function that an L2 normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitLogSoftmaxLayer (const armnn::IConnectableLayer *layer, const armnn::LogSoftmaxDescriptor &logSoftmaxDescriptor, const char *name=nullptr) override
	Function that a log softmax layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitLstmLayer (const armnn::IConnectableLayer *layer, const armnn::LstmDescriptor &descriptor, const armnn::LstmInputParams &params, const char *name=nullptr) override
	Function an Lstm layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMeanLayer (const armnn::IConnectableLayer *layer, const armnn::MeanDescriptor &descriptor, const char *name) override
	Function a Mean layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMinimumLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a Minimum layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMaximumLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a Maximum layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMergeLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function that a merge layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMergerLayer (const armnn::IConnectableLayer *layer, const armnn::MergerDescriptor &mergerDescriptor, const char *name=nullptr) override
	Function that a merger layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitMultiplicationLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function that a multiplication layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitOutputLayer (const armnn::IConnectableLayer *layer, armnn::LayerBindingId id, const char *name=nullptr) override
	Function an output layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitPadLayer (const armnn::IConnectableLayer *layer, const armnn::PadDescriptor &PadDescriptor, const char *name=nullptr) override
	Function a pad layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitPermuteLayer (const armnn::IConnectableLayer *layer, const armnn::PermuteDescriptor &PermuteDescriptor, const char *name=nullptr) override
	Function that a permute layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitPooling2dLayer (const armnn::IConnectableLayer *layer, const armnn::Pooling2dDescriptor &pooling2dDescriptor, const char *name=nullptr) override
	Function that a pooling layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitPreluLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function that a PReLU activation layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitQuantizeLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a quantize layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitQuantizedLstmLayer (const armnn::IConnectableLayer *layer, const armnn::QuantizedLstmInputParams &params, const char *name=nullptr) override
	Function a QuantizedLstm layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitReshapeLayer (const armnn::IConnectableLayer *layer, const armnn::ReshapeDescriptor &reshapeDescriptor, const char *name=nullptr) override
	Function a reshape layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitResizeLayer (const armnn::IConnectableLayer *layer, const armnn::ResizeDescriptor &resizeDescriptor, const char *name=nullptr) override
	Function that a resize layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitResizeBilinearLayer (const armnn::IConnectableLayer *layer, const armnn::ResizeBilinearDescriptor &resizeDescriptor, const char *name=nullptr) override
	Function that a resize bilinear layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitRsqrtLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a Reciprocal of square root layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSliceLayer (const armnn::IConnectableLayer *layer, const armnn::SliceDescriptor &sliceDescriptor, const char *name=nullptr) override
	Function that a slice layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSoftmaxLayer (const armnn::IConnectableLayer *layer, const armnn::SoftmaxDescriptor &softmaxDescriptor, const char *name=nullptr) override
	Function that a softmax layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSpaceToBatchNdLayer (const armnn::IConnectableLayer *layer, const armnn::SpaceToBatchNdDescriptor &spaceToBatchNdDescriptor, const char *name=nullptr) override
	Function a space to batch layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSpaceToDepthLayer (const armnn::IConnectableLayer *layer, const armnn::SpaceToDepthDescriptor &spaceToDepthDescriptor, const char *name=nullptr) override
	Function a space to depth layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitNormalizationLayer (const armnn::IConnectableLayer *layer, const armnn::NormalizationDescriptor &normalizationDescriptor, const char *name=nullptr) override
	Function that a normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSplitterLayer (const armnn::IConnectableLayer *layer, const armnn::ViewsDescriptor &viewsDescriptor, const char *name=nullptr) override
	Function that a splitter layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitStandInLayer (const armnn::IConnectableLayer *layer, const armnn::StandInDescriptor &standInDescriptor, const char *name=nullptr) override
	Function a StandInLayer should call back to when its Accept(ILaterVisitor&) function is invoked. More...
void	VisitStackLayer (const armnn::IConnectableLayer *layer, const armnn::StackDescriptor &stackDescriptor, const char *name=nullptr) override
	Function a stack layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitStridedSliceLayer (const armnn::IConnectableLayer *layer, const armnn::StridedSliceDescriptor &stridedSliceDescriptor, const char *name=nullptr) override
	Function a strided slice layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSubtractionLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a subtraction layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitSwitchLayer (const armnn::IConnectableLayer *layer, const char *name=nullptr) override
	Function a switch layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitTransposeConvolution2dLayer (const armnn::IConnectableLayer *layer, const armnn::TransposeConvolution2dDescriptor &descriptor, const armnn::ConstTensor &weights, const armnn::Optional< armnn::ConstTensor > &biases, const char *=nullptr) override
	Function that a 2D transpose convolution layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
void	VisitTransposeLayer (const armnn::IConnectableLayer *layer, const armnn::TransposeDescriptor &descriptor, const char *name=nullptr) override
	Function that a transpose layer should call back to when its Accept(ILayerVisitor&) function is invoked. More...
Public Member Functions inherited from ILayerVisitor
virtual void	StartVisit ()
virtual void	FinishVisit ()

Additional Inherited Members
Protected Member Functions inherited from ILayerVisitor
	ILayerVisitor ()
virtual	~ILayerVisitor ()

Detailed Description

Definition at line 21 of file Serializer.hpp.

Constructor & Destructor Documentation

SerializerVisitor()

SerializerVisitor ( )

inline

Definition at line 24 of file Serializer.hpp.

: m_layerId(0) {}

~SerializerVisitor()

~SerializerVisitor ( )

inline

Definition at line 25 of file Serializer.hpp.

{}

Member Function Documentation

GetFlatBufferBuilder()

flatbuffers::FlatBufferBuilder& GetFlatBufferBuilder ( )

inline

Definition at line 27 of file Serializer.hpp.

    {
        return m_flatBufferBuilder;
    }

GetInputIds()

std::vector<int>& GetInputIds ( )

inline

Definition at line 32 of file Serializer.hpp.

    {
        return m_inputIds;
    }

GetOutputIds()

std::vector<int>& GetOutputIds ( )

inline

Definition at line 37 of file Serializer.hpp.

    {
        return m_outputIds;
    }

GetSerializedLayers()

std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer> >& GetSerializedLayers ( )

inline

Definition at line 42 of file Serializer.hpp.

References anchors(), ARMNN_DEPRECATED_MSG, SerializerVisitor::GetVersionTable(), SerializerVisitor::VisitAbsLayer(), SerializerVisitor::VisitActivationLayer(), SerializerVisitor::VisitAdditionLayer(), SerializerVisitor::VisitArgMinMaxLayer(), SerializerVisitor::VisitBatchNormalizationLayer(), SerializerVisitor::VisitBatchToSpaceNdLayer(), SerializerVisitor::VisitComparisonLayer(), SerializerVisitor::VisitConcatLayer(), SerializerVisitor::VisitConstantLayer(), SerializerVisitor::VisitConvolution2dLayer(), SerializerVisitor::VisitDepthToSpaceLayer(), SerializerVisitor::VisitDepthwiseConvolution2dLayer(), SerializerVisitor::VisitDequantizeLayer(), SerializerVisitor::VisitDetectionPostProcessLayer(), SerializerVisitor::VisitDivisionLayer(), SerializerVisitor::VisitElementwiseUnaryLayer(), SerializerVisitor::VisitEqualLayer(), SerializerVisitor::VisitFloorLayer(), SerializerVisitor::VisitFullyConnectedLayer(), SerializerVisitor::VisitGatherLayer(), SerializerVisitor::VisitGreaterLayer(), SerializerVisitor::VisitInputLayer(), SerializerVisitor::VisitInstanceNormalizationLayer(), SerializerVisitor::VisitL2NormalizationLayer(), SerializerVisitor::VisitLogSoftmaxLayer(), SerializerVisitor::VisitLstmLayer(), SerializerVisitor::VisitMaximumLayer(), SerializerVisitor::VisitMeanLayer(), SerializerVisitor::VisitMergeLayer(), SerializerVisitor::VisitMergerLayer(), SerializerVisitor::VisitMinimumLayer(), SerializerVisitor::VisitMultiplicationLayer(), SerializerVisitor::VisitNormalizationLayer(), SerializerVisitor::VisitOutputLayer(), SerializerVisitor::VisitPadLayer(), SerializerVisitor::VisitPermuteLayer(), SerializerVisitor::VisitPooling2dLayer(), SerializerVisitor::VisitPreluLayer(), SerializerVisitor::VisitQuantizedLstmLayer(), SerializerVisitor::VisitQuantizeLayer(), SerializerVisitor::VisitReshapeLayer(), SerializerVisitor::VisitResizeBilinearLayer(), SerializerVisitor::VisitResizeLayer(), SerializerVisitor::VisitRsqrtLayer(), SerializerVisitor::VisitSliceLayer(), SerializerVisitor::VisitSoftmaxLayer(), SerializerVisitor::VisitSpaceToBatchNdLayer(), SerializerVisitor::VisitSpaceToDepthLayer(), SerializerVisitor::VisitSplitterLayer(), SerializerVisitor::VisitStackLayer(), SerializerVisitor::VisitStandInLayer(), SerializerVisitor::VisitStridedSliceLayer(), SerializerVisitor::VisitSubtractionLayer(), SerializerVisitor::VisitSwitchLayer(), SerializerVisitor::VisitTransposeConvolution2dLayer(), and SerializerVisitor::VisitTransposeLayer().

    {
        return m_serializedLayers;
    }

GetVersionTable()

flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable

(

)

Definition at line 1483 of file Serializer.cpp.

References IOutputSlot::CalculateIndexOnOwner(), IInputSlot::GetConnection(), TensorInfo::GetDataType(), armnnSerializer::GetFlatBufferDataType(), IConnectableLayer::GetInputSlot(), TensorShape::GetNumDimensions(), IConnectableLayer::GetNumInputSlots(), IConnectableLayer::GetNumOutputSlots(), IConnectableLayer::GetOutputSlot(), IOutputSlot::GetOwningLayerGuid(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetShape(), and IOutputSlot::GetTensorInfo().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> versionsTable =
        serializer::CreateFeatureCompatibilityVersions(
                m_flatBufferBuilder,
                1 // Binding ids scheme version
            );
    return versionsTable;
}

VisitAbsLayer()

void VisitAbsLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function an absolute layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 129 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Abs);
    auto flatBufferAbsLayer  = serializer::CreateAbsLayer(m_flatBufferBuilder, flatBufferBaseLayer);

    CreateAnyLayer(flatBufferAbsLayer.o, serializer::Layer::Layer_AbsLayer);
}

VisitActivationLayer()

void VisitActivationLayer ( const armnn::IConnectableLayer *  layer, const armnn::ActivationDescriptor &  activationDescriptor, const char *  name = nullptr  )

overridevirtual

Function that an activation layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
activationDescriptor	- ActivationDescriptor to configure the activation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 139 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferActivationFunction(), armnn::IgnoreUnused(), ActivationDescriptor::m_A, ActivationDescriptor::m_B, and ActivationDescriptor::m_Function.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Activation);

    // Create the FlatBuffer ActivationDescriptor
    auto flatBufferDescriptor = CreateActivationDescriptor(m_flatBufferBuilder,
                                                           GetFlatBufferActivationFunction(descriptor.m_Function),
                                                           descriptor.m_A,
                                                           descriptor.m_B);

    // Create the FlatBuffer ActivationLayer
    auto flatBufferAdditionLayer = CreateActivationLayer(m_flatBufferBuilder,
                                                         flatBufferBaseLayer,
                                                         flatBufferDescriptor);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferAdditionLayer.o, serializer::Layer::Layer_ActivationLayer);
}

VisitAdditionLayer()

void VisitAdditionLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function that an addition layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 164 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferAdditionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Addition);

    // Create the FlatBuffer AdditionLayer
    auto flatBufferAdditionLayer = serializer::CreateAdditionLayer(m_flatBufferBuilder, flatBufferAdditionBaseLayer);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferAdditionLayer.o, serializer::Layer::Layer_AdditionLayer);
}

VisitArgMinMaxLayer()

void VisitArgMinMaxLayer ( const armnn::IConnectableLayer *  layer, const armnn::ArgMinMaxDescriptor &  argMinMaxDescriptor, const char *  name = nullptr  )

overridevirtual

Function that an arg min max layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
argMinMaxDescriptor	- ArgMinMaxDescriptor to configure the activation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 179 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferArgMinMaxFunction(), armnn::IgnoreUnused(), ArgMinMaxDescriptor::m_Axis, and ArgMinMaxDescriptor::m_Function.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ArgMinMax);

    // Create FlatBuffer Descriptor
    auto flatBufferDescriptor = CreateArgMinMaxDescriptor(m_flatBufferBuilder,
                                                          GetFlatBufferArgMinMaxFunction(descriptor.m_Function),
                                                          descriptor.m_Axis);

    // Create FlatBuffer ArgMinMaxLayer
    auto flatBufferLayer = CreateArgMinMaxLayer(m_flatBufferBuilder,
                                                flatBufferBaseLayer,
                                                flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ArgMinMaxLayer);
}

VisitBatchNormalizationLayer()

void VisitBatchNormalizationLayer ( const armnn::IConnectableLayer *  layer, const armnn::BatchNormalizationDescriptor &  desc, const armnn::ConstTensor &  mean, const armnn::ConstTensor &  variance, const armnn::ConstTensor &  beta, const armnn::ConstTensor &  gamma, const char *  name = nullptr  )

overridevirtual

Function that a batch normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
mean	- Pre-calculated mean for each channel.
variance	- Pre-calculated variance for each channel.
beta	- Per-channel additive factor.
gamma	- Per-channel multiplicative factor.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 232 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), BatchNormalizationDescriptor::m_DataLayout, and BatchNormalizationDescriptor::m_Eps.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBatchNormalizationBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchNormalization);
    auto fbBatchNormalizationDescriptor = serializer::CreateBatchNormalizationDescriptor(
                                                  m_flatBufferBuilder,
                                                  batchNormDescriptor.m_Eps,
                                                  GetFlatBufferDataLayout(batchNormDescriptor.m_DataLayout));

    auto fbMeanConstTensorInfo     = CreateConstTensorInfo(mean);
    auto fbVarianceConstTensorInfo = CreateConstTensorInfo(variance);
    auto fbBetaConstTensorInfo     = CreateConstTensorInfo(beta);
    auto fbGammaConstTensorInfo    = CreateConstTensorInfo(gamma);
    auto fbBatchNormalizationLayer = serializer::CreateBatchNormalizationLayer(m_flatBufferBuilder,
                                                                               fbBatchNormalizationBaseLayer,
                                                                               fbBatchNormalizationDescriptor,
                                                                               fbMeanConstTensorInfo,
                                                                               fbVarianceConstTensorInfo,
                                                                               fbBetaConstTensorInfo,
                                                                               fbGammaConstTensorInfo);

    CreateAnyLayer(fbBatchNormalizationLayer.o, serializer::Layer::Layer_BatchNormalizationLayer);
}

VisitBatchToSpaceNdLayer()

void VisitBatchToSpaceNdLayer ( const armnn::IConnectableLayer *  layer, const armnn::BatchToSpaceNdDescriptor &  batchToSpaceNdDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a batch to space ND layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
batchToSpaceNdDescriptor	- Description of the layer.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 202 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), BatchToSpaceNdDescriptor::m_BlockShape, BatchToSpaceNdDescriptor::m_Crops, and BatchToSpaceNdDescriptor::m_DataLayout.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchToSpaceNd);

    std::vector<unsigned int> crops;
    crops.reserve(descriptor.m_Crops.size() * 2);
    for (auto& crop : descriptor.m_Crops)
    {
        crops.push_back(crop.first);
        crops.push_back(crop.second);
    }

    auto flatBufferDescriptor =
        CreateBatchToSpaceNdDescriptor(m_flatBufferBuilder,
                                       m_flatBufferBuilder.CreateVector(descriptor.m_BlockShape),
                                       m_flatBufferBuilder.CreateVector(crops),
                                       GetFlatBufferDataLayout(descriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateBatchToSpaceNdLayer(m_flatBufferBuilder,
                                                                 flatBufferBaseLayer,
                                                                 flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_BatchToSpaceNdLayer);
}

VisitComparisonLayer()

void VisitComparisonLayer ( const armnn::IConnectableLayer *  layer, const armnn::ComparisonDescriptor &  comparisonDescriptor, const char *  name = nullptr  )

overridevirtual

Function a Comparison layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
comparisonDescriptor	- Description of the layer.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 263 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferComparisonOperation(), armnn::IgnoreUnused(), and ComparisonDescriptor::m_Operation.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Comparison);
    auto fbDescriptor = serializer::CreateComparisonDescriptor(
        m_flatBufferBuilder,
        GetFlatBufferComparisonOperation(descriptor.m_Operation));

    auto fbLayer = serializer::CreateComparisonLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ComparisonLayer);
}

VisitConcatLayer()

void VisitConcatLayer ( const armnn::IConnectableLayer *  layer, const armnn::ConcatDescriptor &  concatDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a concat layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
concatDescriptor	- ConcatDescriptor (synonym for OriginsDescriptor) to configure the concatenation process. Number of Views must be equal to the number of inputs, and their order must match - e.g. first view corresponds to the first input, second view to the second input, etc....
name	- Optional name for the layer.

Reimplemented from ILayerVisitor.

Definition at line 729 of file Serializer.cpp.

References OriginsDescriptor::GetConcatAxis(), OriginsDescriptor::GetNumDimensions(), OriginsDescriptor::GetNumViews(), OriginsDescriptor::GetViewOrigin(), and armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferConcatBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Concat);

    std::vector<flatbuffers::Offset<UintVector>> views;
    for (unsigned int v = 0; v < concatDescriptor.GetNumViews(); ++v)
    {
        const uint32_t* origin = concatDescriptor.GetViewOrigin(v);
        std::vector<uint32_t> origins;
        for (unsigned int d = 0; d < concatDescriptor.GetNumDimensions(); ++d)
        {
            origins.push_back(origin[d]);
        }
        auto view = m_flatBufferBuilder.CreateVector(origins);
        auto uintVector = CreateUintVector(m_flatBufferBuilder, view);
        views.push_back(uintVector);
    }

    auto flatBufferConcatDescriptor = CreateOriginsDescriptor(m_flatBufferBuilder,
                                                              concatDescriptor.GetConcatAxis(),
                                                              concatDescriptor.GetNumViews(),
                                                              concatDescriptor.GetNumDimensions(),
                                                              m_flatBufferBuilder.CreateVector(views));

    auto flatBufferLayer = CreateConcatLayer(m_flatBufferBuilder,
                                             flatBufferConcatBaseLayer,
                                             flatBufferConcatDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ConcatLayer);
}

VisitConstantLayer()

void VisitConstantLayer ( const armnn::IConnectableLayer *  layer, const armnn::ConstTensor &  input, const char *  name = nullptr  )

overridevirtual

Function a layer with no inputs and a single output, which always corresponds to the passed in constant tensor should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
input	- Tensor to be provided as the only output of the layer. The layer will maintain its own copy of the tensor data, meaning the memory referenced by input can be freed or reused after this function is called.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 279 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferConstantBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Constant);

    auto flatBufferConstTensorInfo = CreateConstTensorInfo(input);

    // Create the FlatBuffer ConstantLayer
    auto flatBufferLayer = CreateConstantLayer(m_flatBufferBuilder,
                                               flatBufferConstantBaseLayer,
                                               flatBufferConstTensorInfo);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ConstantLayer);
}

VisitConvolution2dLayer()

void VisitConvolution2dLayer ( const armnn::IConnectableLayer *  layer, const armnn::Convolution2dDescriptor &  convolution2dDescriptor, const armnn::ConstTensor &  weights, const armnn::Optional< armnn::ConstTensor > &  biases, const char *  name = nullptr  )

overridevirtual

Function that a 2D convolution layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
convolution2dDescriptor	- Description of the 2D convolution layer.
weights	- Tensor for the weights data.
biases	- Optional tensor for the bias data. If specified, must match the output tensor shape.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 300 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), OptionalBase::has_value(), armnn::IgnoreUnused(), Convolution2dDescriptor::m_BiasEnabled, Convolution2dDescriptor::m_DataLayout, Convolution2dDescriptor::m_DilationX, Convolution2dDescriptor::m_DilationY, Convolution2dDescriptor::m_PadBottom, Convolution2dDescriptor::m_PadLeft, Convolution2dDescriptor::m_PadRight, Convolution2dDescriptor::m_PadTop, Convolution2dDescriptor::m_StrideX, Convolution2dDescriptor::m_StrideY, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);

    auto flatBufferDescriptor = CreateConvolution2dDescriptor(m_flatBufferBuilder,
                                                              descriptor.m_PadLeft,
                                                              descriptor.m_PadRight,
                                                              descriptor.m_PadTop,
                                                              descriptor.m_PadBottom,
                                                              descriptor.m_StrideX,
                                                              descriptor.m_StrideY,
                                                              descriptor.m_DilationX,
                                                              descriptor.m_DilationY,
                                                              descriptor.m_BiasEnabled,
                                                              GetFlatBufferDataLayout(descriptor.m_DataLayout));
    auto flatBufferWeightsConstTensorInfo = CreateConstTensorInfo(weights);
    flatbuffers::Offset<serializer::ConstTensor> flatBufferBiasesConstTensorInfo;

    if (biases.has_value())
    {
        flatBufferBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
    }

    // Create the FlatBuffer Convolution2dLayer
    auto flatBufferLayer = CreateConvolution2dLayer(m_flatBufferBuilder,
                                                    flatBufferBaseLayer,
                                                    flatBufferDescriptor,
                                                    flatBufferWeightsConstTensorInfo,
                                                    flatBufferBiasesConstTensorInfo);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_Convolution2dLayer);
}

VisitDepthToSpaceLayer()

void VisitDepthToSpaceLayer ( const armnn::IConnectableLayer *  layer, const armnn::DepthToSpaceDescriptor &  depthToSpaceDescriptor, const char *  name = nullptr  )

overridevirtual

Function a depth to space layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
depthToSpaceDescriptor	- Parameters for the depth to space operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 341 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), SpaceToDepthDescriptor::m_BlockSize, and SpaceToDepthDescriptor::m_DataLayout.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthToSpace);
    auto fbDescriptor = CreateDepthToSpaceDescriptor(m_flatBufferBuilder,
                                                     descriptor.m_BlockSize,
                                                     GetFlatBufferDataLayout(descriptor.m_DataLayout));

    auto fbLayer = serializer::CreateDepthToSpaceLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);

    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_DepthToSpaceLayer);
}

VisitDepthwiseConvolution2dLayer()

void VisitDepthwiseConvolution2dLayer ( const armnn::IConnectableLayer *  layer, const armnn::DepthwiseConvolution2dDescriptor &  convolution2dDescriptor, const armnn::ConstTensor &  weights, const armnn::Optional< armnn::ConstTensor > &  biases, const char *  name = nullptr  )

overridevirtual

Function that a 2D depthwise convolution layer with biases should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
convolution2dDescriptor	- Description of the 2D depthwise convolution layer.
weights	- Tensor for the weights. Expected format: [channelMultiplier, inputChannels, height, width].
biases	- Optional tensor for the bias data. If specified, must match the output tensor shape.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 357 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), OptionalBase::has_value(), armnn::IgnoreUnused(), DepthwiseConvolution2dDescriptor::m_BiasEnabled, DepthwiseConvolution2dDescriptor::m_DataLayout, DepthwiseConvolution2dDescriptor::m_DilationX, DepthwiseConvolution2dDescriptor::m_DilationY, DepthwiseConvolution2dDescriptor::m_PadBottom, DepthwiseConvolution2dDescriptor::m_PadLeft, DepthwiseConvolution2dDescriptor::m_PadRight, DepthwiseConvolution2dDescriptor::m_PadTop, DepthwiseConvolution2dDescriptor::m_StrideX, DepthwiseConvolution2dDescriptor::m_StrideY, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthwiseConvolution2d);
    auto fbDescriptor = CreateDepthwiseConvolution2dDescriptor(m_flatBufferBuilder,
                                                               descriptor.m_PadLeft,
                                                               descriptor.m_PadRight,
                                                               descriptor.m_PadTop,
                                                               descriptor.m_PadBottom,
                                                               descriptor.m_StrideX,
                                                               descriptor.m_StrideY,
                                                               descriptor.m_DilationX,
                                                               descriptor.m_DilationY,
                                                               descriptor.m_BiasEnabled,
                                                               GetFlatBufferDataLayout(descriptor.m_DataLayout));

    flatbuffers::Offset<serializer::ConstTensor> fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
    flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
    if (biases.has_value())
    {
        fbBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
    }

    auto flatBufferLayer = CreateDepthwiseConvolution2dLayer(m_flatBufferBuilder,
                                                             fbBaseLayer,
                                                             fbDescriptor,
                                                             fbWeightsConstTensorInfo,
                                                             fbBiasesConstTensorInfo);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DepthwiseConvolution2dLayer);
}

VisitDequantizeLayer()

void VisitDequantizeLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function that a Dequantize layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 394 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbDequantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Dequantize);
    auto fbDequantizeLayer     = serializer::CreateDequantizeLayer(m_flatBufferBuilder, fbDequantizeBaseLayer);

    CreateAnyLayer(fbDequantizeLayer.o, serializer::Layer::Layer_DequantizeLayer);
}

VisitDetectionPostProcessLayer()

void VisitDetectionPostProcessLayer ( const armnn::IConnectableLayer *  layer, const armnn::DetectionPostProcessDescriptor &  descriptor, const armnn::ConstTensor &  anchors, const char *  name = nullptr  )

overridevirtual

Function that a Detection PostProcess layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
descriptor	- Description of the Detection PostProcess layer.
anchors	- Tensor for the anchors.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 405 of file Serializer.cpp.

References armnn::IgnoreUnused(), DetectionPostProcessDescriptor::m_DetectionsPerClass, DetectionPostProcessDescriptor::m_MaxClassesPerDetection, DetectionPostProcessDescriptor::m_MaxDetections, DetectionPostProcessDescriptor::m_NmsIouThreshold, DetectionPostProcessDescriptor::m_NmsScoreThreshold, DetectionPostProcessDescriptor::m_NumClasses, DetectionPostProcessDescriptor::m_ScaleH, DetectionPostProcessDescriptor::m_ScaleW, DetectionPostProcessDescriptor::m_ScaleX, DetectionPostProcessDescriptor::m_ScaleY, and DetectionPostProcessDescriptor::m_UseRegularNms.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_DetectionPostProcess);
    auto fbDescriptor = CreateDetectionPostProcessDescriptor(m_flatBufferBuilder,
                                                             descriptor.m_MaxDetections,
                                                             descriptor.m_MaxClassesPerDetection,
                                                             descriptor.m_DetectionsPerClass,
                                                             descriptor.m_NmsScoreThreshold,
                                                             descriptor.m_NmsIouThreshold,
                                                             descriptor.m_NumClasses,
                                                             descriptor.m_UseRegularNms,
                                                             descriptor.m_ScaleX,
                                                             descriptor.m_ScaleY,
                                                             descriptor.m_ScaleW,
                                                             descriptor.m_ScaleH);

    flatbuffers::Offset<serializer::ConstTensor> fbAnchorsConstTensorInfo = CreateConstTensorInfo(anchors);

    auto flatBufferLayer = CreateDetectionPostProcessLayer(m_flatBufferBuilder,
                                                           fbBaseLayer,
                                                           fbDescriptor,
                                                           fbAnchorsConstTensorInfo);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DetectionPostProcessLayer);
}

VisitDivisionLayer()

void VisitDivisionLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a division layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 436 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbDivisionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Division);
    auto fbDivisionLayer     = serializer::CreateDivisionLayer(m_flatBufferBuilder, fbDivisionBaseLayer);

    CreateAnyLayer(fbDivisionLayer.o, serializer::Layer::Layer_DivisionLayer);
}

VisitElementwiseUnaryLayer()

void VisitElementwiseUnaryLayer ( const armnn::IConnectableLayer *  layer, const armnn::ElementwiseUnaryDescriptor &  elementwiseUnaryDescriptor, const char *  name = nullptr  )

overridevirtual

Function a ElementwiseUnary layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
elementwiseUnaryDescriptor	- Description of the layer.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 446 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferUnaryOperation(), armnn::IgnoreUnused(), and ElementwiseUnaryDescriptor::m_Operation.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_ElementwiseUnary);
    auto fbDescriptor = serializer::CreateElementwiseUnaryDescriptor(
        m_flatBufferBuilder,
        GetFlatBufferUnaryOperation(descriptor.m_Operation));

    auto fbLayer = serializer::CreateElementwiseUnaryLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);
    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ElementwiseUnaryLayer);
}

VisitEqualLayer()

void VisitEqualLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function an Equal layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 461 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Equal);
    auto fbEqualLayer = serializer::CreateEqualLayer(m_flatBufferBuilder, fbBaseLayer);

    CreateAnyLayer(fbEqualLayer.o, serializer::Layer::Layer_EqualLayer);
}

VisitFloorLayer()

void VisitFloorLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a floor layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 471 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferFloorBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Floor);
    auto flatBufferFloorLayer = serializer::CreateFloorLayer(m_flatBufferBuilder, flatBufferFloorBaseLayer);

    CreateAnyLayer(flatBufferFloorLayer.o, serializer::Layer::Layer_FloorLayer);
}

VisitFullyConnectedLayer()

void VisitFullyConnectedLayer ( const armnn::IConnectableLayer *  layer, const armnn::FullyConnectedDescriptor &  fullyConnectedDescriptor, const armnn::ConstTensor &  weights, const armnn::Optional< armnn::ConstTensor > &  biases, const char *  name = nullptr  )

overridevirtual

Function that a fully connected layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
fullyConnectedDescriptor	- Description of the fully connected layer.
weights	- Tensor for the weights data.
biases	- Optional tensor for the bias data.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1002 of file Serializer.cpp.

References armnn::IgnoreUnused(), FullyConnectedDescriptor::m_BiasEnabled, FullyConnectedDescriptor::m_TransposeWeightMatrix, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_FullyConnected);

    // Create FlatBuffer FullyConnectedDescriptor
    auto flatBufferDescriptor =
        serializer::CreateFullyConnectedDescriptor(m_flatBufferBuilder,
                                                   fullyConnectedDescriptor.m_BiasEnabled,
                                                   fullyConnectedDescriptor.m_TransposeWeightMatrix);

    // Create FlatBuffer weights data
    auto flatBufferWeights = CreateConstTensorInfo(weights);

    // Create FlatBuffer bias data
    flatbuffers::Offset<serializer::ConstTensor> flatBufferBiases;
    if (fullyConnectedDescriptor.m_BiasEnabled)
    {
        flatBufferBiases = CreateConstTensorInfo(biases.value());
    }

    // Create FlatBuffer FullyConnectedLayer
    auto flatBufferLayer = serializer::CreateFullyConnectedLayer(m_flatBufferBuilder,
                                                                 flatBufferBaseLayer,
                                                                 flatBufferDescriptor,
                                                                 flatBufferWeights,
                                                                 flatBufferBiases);

    // Add created FullyConnectedLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_FullyConnectedLayer);
}

VisitGatherLayer()

void VisitGatherLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a Gather layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 481 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbGatherBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Gather);
    auto flatBufferLayer   = serializer::CreateGatherLayer(m_flatBufferBuilder, fbGatherBaseLayer);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_GatherLayer);
}

VisitGreaterLayer()

void VisitGreaterLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a Greater layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 491 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbGreaterBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Greater);
    auto fbGreaterLayer = serializer::CreateGreaterLayer(m_flatBufferBuilder, fbGreaterBaseLayer);

    CreateAnyLayer(fbGreaterLayer.o, serializer::Layer::Layer_GreaterLayer);
}

VisitInputLayer()

void VisitInputLayer ( const armnn::IConnectableLayer *  layer, armnn::LayerBindingId  id, const char *  name = nullptr  )

overridevirtual

Function that an InputLayer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
id	- User generated id to uniquely identify a particular input. The same id needs to be specified when passing the inputs to the IRuntime::EnqueueWorkload() function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 87 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferInputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Input);

    // Create FlatBuffer BindableBaseLayer
    auto flatBufferInputBindableBaseLayer = serializer::CreateBindableLayerBase(m_flatBufferBuilder,
                                                                                flatBufferInputBaseLayer,
                                                                                id);
    // Push layer binding id to outputIds.
    m_inputIds.push_back(id);

    // Create the FlatBuffer InputLayer
    auto flatBufferInputLayer = serializer::CreateInputLayer(m_flatBufferBuilder, flatBufferInputBindableBaseLayer);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferInputLayer.o, serializer::Layer::Layer_InputLayer);
}

VisitInstanceNormalizationLayer()

void VisitInstanceNormalizationLayer ( const armnn::IConnectableLayer *  layer, const armnn::InstanceNormalizationDescriptor &  desc, const char *  name = nullptr  )

overridevirtual

Function that an instance normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
desc	- Parameters for the instance normalization operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 501 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), InstanceNormalizationDescriptor::m_Beta, InstanceNormalizationDescriptor::m_DataLayout, InstanceNormalizationDescriptor::m_Eps, and InstanceNormalizationDescriptor::m_Gamma.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbDescriptor = serializer::CreateInstanceNormalizationDescriptor(
            m_flatBufferBuilder,
            instanceNormalizationDescriptor.m_Gamma,
            instanceNormalizationDescriptor.m_Beta,
            instanceNormalizationDescriptor.m_Eps,
            GetFlatBufferDataLayout(instanceNormalizationDescriptor.m_DataLayout));

    auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_InstanceNormalization);
    auto fbLayer     = serializer::CreateInstanceNormalizationLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);

    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_InstanceNormalizationLayer);
}

VisitL2NormalizationLayer()

void VisitL2NormalizationLayer ( const armnn::IConnectableLayer *  layer, const armnn::L2NormalizationDescriptor &  desc, const char *  name = nullptr  )

overridevirtual

Function that an L2 normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Normalization is performed along dimension 1, but requires a 4d input.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
desc	- Parameters for the L2 normalization operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 521 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), L2NormalizationDescriptor::m_DataLayout, and L2NormalizationDescriptor::m_Eps.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_L2Normalization);

    // Create the FlatBuffer L2Normalization Descriptor
    auto fbDescriptor = serializer::CreateL2NormalizationDescriptor(
            m_flatBufferBuilder,
            GetFlatBufferDataLayout(l2NormalizationDescriptor.m_DataLayout),
            l2NormalizationDescriptor.m_Eps);

    // Create FlatBuffer layer
    auto fbLayer = serializer::CreateL2NormalizationLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);

    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_L2NormalizationLayer);
}

VisitLogSoftmaxLayer()

void VisitLogSoftmaxLayer ( const armnn::IConnectableLayer *  layer, const armnn::LogSoftmaxDescriptor &  logSoftmaxDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a log softmax layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
logSoftmaxDescriptor	- LogSoftmaxDescriptor to configure the log softmax.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 542 of file Serializer.cpp.

References armnn::IgnoreUnused(), SoftmaxDescriptor::m_Axis, and SoftmaxDescriptor::m_Beta.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferLogSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_LogSoftmax);

    // Create the FlatBuffer LogSoftmaxDescriptor
    auto flatBufferLogSoftmaxDesc =
        serializer::CreateLogSoftmaxDescriptor(m_flatBufferBuilder,
                                               logSoftmaxDescriptor.m_Beta,
                                               logSoftmaxDescriptor.m_Axis);

    // Create the FlatBuffer LogSoftmaxLayer
    auto flatBufferLogSoftmaxLayer =
        serializer::CreateLogSoftmaxLayer(m_flatBufferBuilder,
                                          flatBufferLogSoftmaxBaseLayer,
                                          flatBufferLogSoftmaxDesc);

    CreateAnyLayer(flatBufferLogSoftmaxLayer.o, serializer::Layer::Layer_LogSoftmaxLayer);
}

VisitLstmLayer()

void VisitLstmLayer ( const armnn::IConnectableLayer *  layer, const armnn::LstmDescriptor &  descriptor, const armnn::LstmInputParams &  params, const char *  name = nullptr  )

overridevirtual

Function an Lstm layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
descriptor	- Parameters controlling the operation of the Lstm operation.
params	- The weights and biases for the LSTM cell.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 566 of file Serializer.cpp.

References armnn::IgnoreUnused(), LstmDescriptor::m_ActivationFunc, LstmInputParams::m_CellBias, LstmInputParams::m_CellLayerNormWeights, LstmInputParams::m_CellToForgetWeights, LstmInputParams::m_CellToInputWeights, LstmInputParams::m_CellToOutputWeights, LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_ClippingThresCell, LstmDescriptor::m_ClippingThresProj, LstmInputParams::m_ForgetGateBias, LstmInputParams::m_ForgetLayerNormWeights, LstmInputParams::m_InputGateBias, LstmInputParams::m_InputLayerNormWeights, LstmInputParams::m_InputToCellWeights, LstmInputParams::m_InputToForgetWeights, LstmInputParams::m_InputToInputWeights, LstmInputParams::m_InputToOutputWeights, LstmDescriptor::m_LayerNormEnabled, LstmInputParams::m_OutputGateBias, LstmInputParams::m_OutputLayerNormWeights, LstmDescriptor::m_PeepholeEnabled, LstmInputParams::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, LstmInputParams::m_ProjectionWeights, LstmInputParams::m_RecurrentToCellWeights, LstmInputParams::m_RecurrentToForgetWeights, LstmInputParams::m_RecurrentToInputWeights, and LstmInputParams::m_RecurrentToOutputWeights.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Lstm);

    auto fbLstmDescriptor = serializer::CreateLstmDescriptor(
        m_flatBufferBuilder,
        descriptor.m_ActivationFunc,
        descriptor.m_ClippingThresCell,
        descriptor.m_ClippingThresProj,
        descriptor.m_CifgEnabled,
        descriptor.m_PeepholeEnabled,
        descriptor.m_ProjectionEnabled,
        descriptor.m_LayerNormEnabled);

    // Get mandatory input parameters
    auto inputToForgetWeights = CreateConstTensorInfo(*params.m_InputToForgetWeights);
    auto inputToCellWeights = CreateConstTensorInfo(*params.m_InputToCellWeights);
    auto inputToOutputWeights = CreateConstTensorInfo(*params.m_InputToOutputWeights);
    auto recurrentToForgetWeights = CreateConstTensorInfo(*params.m_RecurrentToForgetWeights);
    auto recurrentToCellWeights = CreateConstTensorInfo(*params.m_RecurrentToCellWeights);
    auto recurrentToOutputWeights = CreateConstTensorInfo(*params.m_RecurrentToOutputWeights);
    auto forgetGateBias = CreateConstTensorInfo(*params.m_ForgetGateBias);
    auto cellBias = CreateConstTensorInfo(*params.m_CellBias);
    auto outputGateBias = CreateConstTensorInfo(*params.m_OutputGateBias);

    //Define optional parameters, these will be set depending on configuration in Lstm descriptor
    flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
    flatbuffers::Offset<serializer::ConstTensor> recurrentToInputWeights;
    flatbuffers::Offset<serializer::ConstTensor> cellToInputWeights;
    flatbuffers::Offset<serializer::ConstTensor> inputGateBias;
    flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
    flatbuffers::Offset<serializer::ConstTensor> projectionBias;
    flatbuffers::Offset<serializer::ConstTensor> cellToForgetWeights;
    flatbuffers::Offset<serializer::ConstTensor> cellToOutputWeights;
    flatbuffers::Offset<serializer::ConstTensor> inputLayerNormWeights;
    flatbuffers::Offset<serializer::ConstTensor> forgetLayerNormWeights;
    flatbuffers::Offset<serializer::ConstTensor> cellLayerNormWeights;
    flatbuffers::Offset<serializer::ConstTensor> outputLayerNormWeights;

    if (!descriptor.m_CifgEnabled)
    {
        inputToInputWeights = CreateConstTensorInfo(*params.m_InputToInputWeights);
        recurrentToInputWeights = CreateConstTensorInfo(*params.m_RecurrentToInputWeights);
        cellToInputWeights = CreateConstTensorInfo(*params.m_CellToInputWeights);
        inputGateBias = CreateConstTensorInfo(*params.m_InputGateBias);
    }

    if (descriptor.m_ProjectionEnabled)
    {
        projectionWeights = CreateConstTensorInfo(*params.m_ProjectionWeights);
        projectionBias = CreateConstTensorInfo(*params.m_ProjectionBias);
    }

    if (descriptor.m_PeepholeEnabled)
    {
        cellToForgetWeights = CreateConstTensorInfo(*params.m_CellToForgetWeights);
        cellToOutputWeights = CreateConstTensorInfo(*params.m_CellToOutputWeights);
    }

    if (descriptor.m_LayerNormEnabled)
    {
        if (!descriptor.m_CifgEnabled)
        {
            inputLayerNormWeights = CreateConstTensorInfo((*params.m_InputLayerNormWeights));
        }
        forgetLayerNormWeights = CreateConstTensorInfo(*params.m_ForgetLayerNormWeights);
        cellLayerNormWeights   = CreateConstTensorInfo(*params.m_CellLayerNormWeights);
        outputLayerNormWeights = CreateConstTensorInfo(*params.m_OutputLayerNormWeights);
    }

    auto fbLstmParams = serializer::CreateLstmInputParams(
        m_flatBufferBuilder,
        inputToForgetWeights,
        inputToCellWeights,
        inputToOutputWeights,
        recurrentToForgetWeights,
        recurrentToCellWeights,
        recurrentToOutputWeights,
        forgetGateBias,
        cellBias,
        outputGateBias,
        inputToInputWeights,
        recurrentToInputWeights,
        cellToInputWeights,
        inputGateBias,
        projectionWeights,
        projectionBias,
        cellToForgetWeights,
        cellToOutputWeights,
        inputLayerNormWeights,
        forgetLayerNormWeights,
        cellLayerNormWeights,
        outputLayerNormWeights);

    auto fbLstmLayer = serializer::CreateLstmLayer(
        m_flatBufferBuilder,
        fbLstmBaseLayer,
        fbLstmDescriptor,
        fbLstmParams);

    CreateAnyLayer(fbLstmLayer.o, serializer::Layer::Layer_LstmLayer);
}

VisitMaximumLayer()

void VisitMaximumLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a Maximum layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 674 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbMaximumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Maximum);
    auto fbMaximumLayer     = serializer::CreateMaximumLayer(m_flatBufferBuilder, fbMaximumBaseLayer);

    CreateAnyLayer(fbMaximumLayer.o, serializer::Layer::Layer_MaximumLayer);
}

VisitMeanLayer()

void VisitMeanLayer ( const armnn::IConnectableLayer *  layer, const armnn::MeanDescriptor &  meanDescriptor, const char *  name  )

overridevirtual

Function a Mean layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
meanDescriptor	- Parameters for the mean operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 684 of file Serializer.cpp.

References armnn::IgnoreUnused(), MeanDescriptor::m_Axis, and MeanDescriptor::m_KeepDims.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbMeanBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Mean);
    auto fbMeanDescriptor = serializer::CreateMeanDescriptor(m_flatBufferBuilder,
                                                             m_flatBufferBuilder.CreateVector(descriptor.m_Axis),
                                                             descriptor.m_KeepDims);

    auto fbMeanLayer = serializer::CreateMeanLayer(m_flatBufferBuilder,
                                                   fbMeanBaseLayer,
                                                   fbMeanDescriptor);

    CreateAnyLayer(fbMeanLayer.o, serializer::Layer::Layer_MeanLayer);
}

VisitMergeLayer()

void VisitMergeLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function that a merge layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 712 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbMergeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Merge);
    auto fbMergeLayer     = serializer::CreateMergeLayer(m_flatBufferBuilder, fbMergeBaseLayer);

    CreateAnyLayer(fbMergeLayer.o, serializer::Layer::Layer_MergeLayer);
}

VisitMergerLayer()

void VisitMergerLayer ( const armnn::IConnectableLayer *  layer, const armnn::MergerDescriptor &  mergerDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a merger layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
mergerDescriptor	- MergerDescriptor (synonym for OriginsDescriptor) to configure the concatenation process. Number of Views must be equal to the number of inputs, and their order must match - e.g. first view corresponds to the first input, second view to the second input, etc....
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 722 of file Serializer.cpp.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    VisitConcatLayer(layer, mergerDescriptor, name);
}

VisitMinimumLayer()

void VisitMinimumLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a Minimum layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 702 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbMinimumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Minimum);
    auto fbMinimumLayer     = serializer::CreateMinimumLayer(m_flatBufferBuilder, fbMinimumBaseLayer);

    CreateAnyLayer(fbMinimumLayer.o, serializer::Layer::Layer_MinimumLayer);
}

VisitMultiplicationLayer()

void VisitMultiplicationLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function that a multiplication layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 764 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbMultiplicationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Multiplication);
    auto fbMultiplicationLayer     = serializer::CreateMultiplicationLayer(m_flatBufferBuilder,
                                                                           fbMultiplicationBaseLayer);

    CreateAnyLayer(fbMultiplicationLayer.o, serializer::Layer::Layer_MultiplicationLayer);
}

VisitNormalizationLayer()

void VisitNormalizationLayer ( const armnn::IConnectableLayer *  layer, const armnn::NormalizationDescriptor &  normalizationDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a normalization layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
normalizationDescriptor	- NormalizationDescriptor to configure the normalization.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1158 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnnSerializer::GetFlatBufferNormalizationAlgorithmChannel(), armnnSerializer::GetFlatBufferNormalizationAlgorithmMethod(), armnn::IgnoreUnused(), NormalizationDescriptor::m_Alpha, NormalizationDescriptor::m_Beta, NormalizationDescriptor::m_DataLayout, NormalizationDescriptor::m_K, NormalizationDescriptor::m_NormChannelType, NormalizationDescriptor::m_NormMethodType, and NormalizationDescriptor::m_NormSize.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(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);
}

VisitOutputLayer()

void VisitOutputLayer ( const armnn::IConnectableLayer *  layer, armnn::LayerBindingId  id, const char *  name = nullptr  )

overridevirtual

Function an output layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
id	- User generated id to uniquely identify a particular output. The same id needs to be specified when passing the outputs to the IRuntime::EnqueueWorkload() function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 109 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferOutputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Output);

    // Create FlatBuffer BindableBaseLayer
    auto flatBufferOutputBindableBaseLayer = serializer::CreateBindableLayerBase(m_flatBufferBuilder,
                                                                                 flatBufferOutputBaseLayer,
                                                                                 id);
    // Push layer binding id to outputIds.
    m_outputIds.push_back(id);

    // Create the FlatBuffer OutputLayer
    auto flatBufferOutputLayer = serializer::CreateOutputLayer(m_flatBufferBuilder, flatBufferOutputBindableBaseLayer);
    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferOutputLayer.o, serializer::Layer::Layer_OutputLayer);
}

VisitPadLayer()

void VisitPadLayer ( const armnn::IConnectableLayer *  layer, const armnn::PadDescriptor &  padDescriptor, const char *  name = nullptr  )

overridevirtual

Function a pad layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
paddings	- n by 2 tensor, where n is the rank of the input tensor, such that paddings[i,0] indicates the amount of padding to add in front of dimension i, and paddings[i,1] indicates the amount of padding to add after the end of dimension i
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 775 of file Serializer.cpp.

References armnn::IgnoreUnused(), PadDescriptor::m_PadList, and PadDescriptor::m_PadValue.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pad);

    std::vector<unsigned int> padList;
    for (auto& p: padDescriptor.m_PadList)
    {
        padList.push_back(p.first);
        padList.push_back(p.second);
    }

    auto flatBufferPadDesc = serializer::CreatePadDescriptor(m_flatBufferBuilder,
                                                             m_flatBufferBuilder.CreateVector(padList),
                                                             padDescriptor.m_PadValue);

    auto flatBufferPadLayer = serializer::CreatePadLayer(m_flatBufferBuilder,
                                                         flatBufferBaseLayer,
                                                         flatBufferPadDesc);

    CreateAnyLayer(flatBufferPadLayer.o, serializer::Layer::Layer_PadLayer);
}

VisitPermuteLayer()

void VisitPermuteLayer ( const armnn::IConnectableLayer *  layer, const armnn::PermuteDescriptor &  permuteDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a permute layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
permuteDescriptor	- PermuteDescriptor to configure the permute.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 801 of file Serializer.cpp.

References PermutationVector::GetSize(), armnn::IgnoreUnused(), and PermuteDescriptor::m_DimMappings.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferPermuteBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Permute);

    std::vector<unsigned int> dimMappings;
    for (unsigned int i=0; i<permuteDescriptor.m_DimMappings.GetSize(); ++i)
    {
        dimMappings.push_back(permuteDescriptor.m_DimMappings[i]);
    }

    auto flatBufferPermuteDesc = serializer::CreatePermuteDescriptor(m_flatBufferBuilder,
                                                                     m_flatBufferBuilder.CreateVector(dimMappings));

    // Create the FlatBuffer PermuteLayer
    auto flatBufferPermuteLayer = serializer::CreatePermuteLayer(m_flatBufferBuilder,
                                                                 flatBufferPermuteBaseLayer,
                                                                 flatBufferPermuteDesc);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferPermuteLayer.o, serializer::Layer::Layer_PermuteLayer);
}

VisitPooling2dLayer()

void VisitPooling2dLayer ( const armnn::IConnectableLayer *  layer, const armnn::Pooling2dDescriptor &  pooling2dDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a pooling layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
pooling2dDescriptor	- Pooling2dDescriptor to configure the pooling.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 947 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnnSerializer::GetFlatBufferOutputShapeRounding(), armnnSerializer::GetFlatBufferPaddingMethod(), armnnSerializer::GetFlatBufferPoolingAlgorithm(), armnn::IgnoreUnused(), Pooling2dDescriptor::m_DataLayout, Pooling2dDescriptor::m_OutputShapeRounding, Pooling2dDescriptor::m_PadBottom, Pooling2dDescriptor::m_PaddingMethod, Pooling2dDescriptor::m_PadLeft, Pooling2dDescriptor::m_PadRight, Pooling2dDescriptor::m_PadTop, Pooling2dDescriptor::m_PoolHeight, Pooling2dDescriptor::m_PoolType, Pooling2dDescriptor::m_PoolWidth, Pooling2dDescriptor::m_StrideX, and Pooling2dDescriptor::m_StrideY.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbPooling2dBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Pooling2d);
    auto fbPooling2dDescriptor = serializer::CreatePooling2dDescriptor(
        m_flatBufferBuilder,
        GetFlatBufferPoolingAlgorithm(pooling2dDescriptor.m_PoolType),
        pooling2dDescriptor.m_PadLeft,
        pooling2dDescriptor.m_PadRight,
        pooling2dDescriptor.m_PadTop,
        pooling2dDescriptor.m_PadBottom,
        pooling2dDescriptor.m_PoolWidth,
        pooling2dDescriptor.m_PoolHeight,
        pooling2dDescriptor.m_StrideX,
        pooling2dDescriptor.m_StrideY,
        GetFlatBufferOutputShapeRounding(pooling2dDescriptor.m_OutputShapeRounding),
        GetFlatBufferPaddingMethod(pooling2dDescriptor.m_PaddingMethod),
        GetFlatBufferDataLayout(pooling2dDescriptor.m_DataLayout));

    auto fbPooling2dLayer = serializer::CreatePooling2dLayer(m_flatBufferBuilder,
                                                             fbPooling2dBaseLayer,
                                                             fbPooling2dDescriptor);

    CreateAnyLayer(fbPooling2dLayer.o, serializer::Layer::Layer_Pooling2dLayer);
}

VisitPreluLayer()

void VisitPreluLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function that a PReLU activation layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 976 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferPreluBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Prelu);

    // Create the FlatBuffer AdditionLayer
    auto flatBufferPreluLayer = serializer::CreatePreluLayer(m_flatBufferBuilder, flatBufferPreluBaseLayer);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferPreluLayer.o, serializer::Layer::Layer_PreluLayer);
}

VisitQuantizedLstmLayer()

void VisitQuantizedLstmLayer ( const armnn::IConnectableLayer *  layer, const armnn::QuantizedLstmInputParams &  params, const char *  name = nullptr  )

overridevirtual

Function a QuantizedLstm layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
params	- The weights and biases for the Quantized LSTM cell
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1333 of file Serializer.cpp.

References armnn::Boolean, armnn::Float16, armnn::Float32, QuantizedLstmInputParams::GetCellBias(), TensorInfo::GetDataType(), armnnSerializer::GetFlatBufferConstTensorData(), armnnSerializer::GetFlatBufferDataType(), QuantizedLstmInputParams::GetForgetGateBias(), IConnectableLayer::GetGuid(), BaseTensor< MemoryType >::GetInfo(), QuantizedLstmInputParams::GetInputGateBias(), QuantizedLstmInputParams::GetInputToCellWeights(), QuantizedLstmInputParams::GetInputToForgetWeights(), QuantizedLstmInputParams::GetInputToInputWeights(), QuantizedLstmInputParams::GetInputToOutputWeights(), BaseTensor< MemoryType >::GetMemoryArea(), IConnectableLayer::GetName(), BaseTensor< MemoryType >::GetNumBytes(), TensorShape::GetNumDimensions(), QuantizedLstmInputParams::GetOutputGateBias(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), QuantizedLstmInputParams::GetRecurrentToCellWeights(), QuantizedLstmInputParams::GetRecurrentToForgetWeights(), QuantizedLstmInputParams::GetRecurrentToInputWeights(), QuantizedLstmInputParams::GetRecurrentToOutputWeights(), TensorInfo::GetShape(), armnn::IgnoreUnused(), armnn::QAsymmU8, armnn::QSymmS16, and armnn::Signed32.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbQuantizedLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QuantizedLstm);

    // Get input parameters
    auto inputToInputWeights = CreateConstTensorInfo(params.GetInputToInputWeights());
    auto inputToForgetWeights = CreateConstTensorInfo(params.GetInputToForgetWeights());
    auto inputToCellWeights = CreateConstTensorInfo(params.GetInputToCellWeights());
    auto inputToOutputWeights = CreateConstTensorInfo(params.GetInputToOutputWeights());

    auto recurrentToInputWeights = CreateConstTensorInfo(params.GetRecurrentToInputWeights());
    auto recurrentToForgetWeights = CreateConstTensorInfo(params.GetRecurrentToForgetWeights());
    auto recurrentToCellWeights = CreateConstTensorInfo(params.GetRecurrentToCellWeights());
    auto recurrentToOutputWeights = CreateConstTensorInfo(params.GetRecurrentToOutputWeights());

    auto inputGateBias = CreateConstTensorInfo(params.GetInputGateBias());
    auto forgetGateBias = CreateConstTensorInfo(params.GetForgetGateBias());
    auto cellBias = CreateConstTensorInfo(params.GetCellBias());
    auto outputGateBias = CreateConstTensorInfo(params.GetOutputGateBias());

    auto fbQuantizedLstmParams = serializer::CreateQuantizedLstmInputParams(
        m_flatBufferBuilder,
        inputToInputWeights,
        inputToForgetWeights,
        inputToCellWeights,
        inputToOutputWeights,
        recurrentToInputWeights,
        recurrentToForgetWeights,
        recurrentToCellWeights,
        recurrentToOutputWeights,
        inputGateBias,
        forgetGateBias,
        cellBias,
        outputGateBias);

    auto fbQuantizedLstmLayer = serializer::CreateQuantizedLstmLayer(
        m_flatBufferBuilder,
        fbQuantizedLstmBaseLayer,
        fbQuantizedLstmParams);

    CreateAnyLayer(fbQuantizedLstmLayer.o, serializer::Layer::Layer_QuantizedLstmLayer);
}

VisitQuantizeLayer()

void VisitQuantizeLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a quantize layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 991 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbQuantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Quantize);
    auto fbQuantizeLayer = serializer::CreateQuantizeLayer(m_flatBufferBuilder,
                                                           fbQuantizeBaseLayer);
    CreateAnyLayer(fbQuantizeLayer.o, serializer::Layer::Layer_QuantizeLayer);
}

VisitReshapeLayer()

void VisitReshapeLayer ( const armnn::IConnectableLayer *  layer, const armnn::ReshapeDescriptor &  reshapeDescriptor, const char *  name = nullptr  )

overridevirtual

Function a reshape layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
reshapeDescriptor	- Parameters for the reshape operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 829 of file Serializer.cpp.

References TensorShape::GetNumDimensions(), armnn::IgnoreUnused(), and ReshapeDescriptor::m_TargetShape.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferReshapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reshape);

    std::vector<unsigned int> targetShape;
    for (unsigned int i =0; i < reshapeDescriptor.m_TargetShape.GetNumDimensions(); i++)
    {
        targetShape.push_back(reshapeDescriptor.m_TargetShape[i]);
    }

    auto flatBufferReshapeDesc = serializer::CreateReshapeDescriptor(m_flatBufferBuilder,
                                                                     m_flatBufferBuilder.CreateVector(targetShape));

    // Create the FlatBuffer ReshapeLayer
    auto flatBufferReshapeLayer = serializer::CreateReshapeLayer(m_flatBufferBuilder, flatBufferReshapeBaseLayer,
                                                                 flatBufferReshapeDesc);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferReshapeLayer.o, serializer::Layer::Layer_ReshapeLayer);
}

VisitResizeBilinearLayer()

void VisitResizeBilinearLayer ( const armnn::IConnectableLayer *  layer, const armnn::ResizeBilinearDescriptor &  resizeDesc, const char *  name = nullptr  )

overridevirtual

Function that a resize bilinear layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
resizeDesc	- Parameters for the resize operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 855 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), ResizeBilinearDescriptor::m_DataLayout, ResizeBilinearDescriptor::m_TargetHeight, and ResizeBilinearDescriptor::m_TargetWidth.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ResizeBilinear);

    auto flatBufferDescriptor =
        CreateResizeBilinearDescriptor(m_flatBufferBuilder,
                                       resizeDescriptor.m_TargetWidth,
                                       resizeDescriptor.m_TargetHeight,
                                       GetFlatBufferDataLayout(resizeDescriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateResizeBilinearLayer(m_flatBufferBuilder,
                                                                 flatBufferBaseLayer,
                                                                 flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeBilinearLayer);
}

VisitResizeLayer()

void VisitResizeLayer ( const armnn::IConnectableLayer *  layer, const armnn::ResizeDescriptor &  resizeDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a resize layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
resizeDescriptor	- Parameters for the resize operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 876 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnnSerializer::GetFlatBufferResizeMethod(), armnn::IgnoreUnused(), ResizeDescriptor::m_DataLayout, ResizeDescriptor::m_Method, ResizeDescriptor::m_TargetHeight, and ResizeDescriptor::m_TargetWidth.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Resize);

    auto flatBufferDescriptor =
            CreateResizeDescriptor(m_flatBufferBuilder,
                                   resizeDescriptor.m_TargetHeight,
                                   resizeDescriptor.m_TargetWidth,
                                   GetFlatBufferResizeMethod(resizeDescriptor.m_Method),
                                   GetFlatBufferDataLayout(resizeDescriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateResizeLayer(m_flatBufferBuilder,
                                                         flatBufferBaseLayer,
                                                         flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeLayer);
}

VisitRsqrtLayer()

void VisitRsqrtLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a Reciprocal of square root layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 898 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbRsqrtBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Rsqrt);
    auto fbRsqrtLayer     = serializer::CreateRsqrtLayer(m_flatBufferBuilder, fbRsqrtBaseLayer);

    CreateAnyLayer(fbRsqrtLayer.o, serializer::Layer::Layer_RsqrtLayer);
}

VisitSliceLayer()

void VisitSliceLayer ( const armnn::IConnectableLayer *  layer, const armnn::SliceDescriptor &  sliceDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a slice layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
sliceDescriptor	- SliceDescriptor to configure the slice operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 908 of file Serializer.cpp.

References armnn::IgnoreUnused(), SliceDescriptor::m_Begin, and SliceDescriptor::m_Size.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbSliceBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Slice);
    auto fbSliceDescriptor = CreateSliceDescriptor(m_flatBufferBuilder,
                                                   m_flatBufferBuilder.CreateVector(sliceDescriptor.m_Begin),
                                                   m_flatBufferBuilder.CreateVector(sliceDescriptor.m_Size));

    auto fbSliceLayer = serializer::CreateSliceLayer(m_flatBufferBuilder, fbSliceBaseLayer, fbSliceDescriptor);

    CreateAnyLayer(fbSliceLayer.o, serializer::Layer::Layer_SliceLayer);
}

VisitSoftmaxLayer()

void VisitSoftmaxLayer ( const armnn::IConnectableLayer *  layer, const armnn::SoftmaxDescriptor &  softmaxDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a softmax layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
softmaxDescriptor	- SoftmaxDescriptor to configure the softmax.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 925 of file Serializer.cpp.

References armnn::IgnoreUnused(), and SoftmaxDescriptor::m_Beta.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Softmax);

    // Create the FlatBuffer SoftmaxDescriptor
    auto flatBufferSoftmaxDesc =
        serializer::CreateSoftmaxDescriptor(m_flatBufferBuilder, softmaxDescriptor.m_Beta);

    // Create the FlatBuffer SoftmaxLayer
    auto flatBufferSoftmaxLayer =
        serializer::CreateSoftmaxLayer(m_flatBufferBuilder,
                                       flatBufferSoftmaxBaseLayer,
                                       flatBufferSoftmaxDesc);

    CreateAnyLayer(flatBufferSoftmaxLayer.o, serializer::Layer::Layer_SoftmaxLayer);
}

VisitSpaceToBatchNdLayer()

void VisitSpaceToBatchNdLayer ( const armnn::IConnectableLayer *  layer, const armnn::SpaceToBatchNdDescriptor &  spaceToBatchNdDescriptor, const char *  name = nullptr  )

overridevirtual

Function a space to batch layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
spaceToBatchNdDescriptor	- Parameters for the space to batch operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1041 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), SpaceToBatchNdDescriptor::m_BlockShape, SpaceToBatchNdDescriptor::m_DataLayout, and SpaceToBatchNdDescriptor::m_PadList.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToBatchNd);

    std::vector<unsigned int> padList;
    padList.reserve(spaceToBatchNdDescriptor.m_PadList.size()*2);
    for (auto& pad : spaceToBatchNdDescriptor.m_PadList)
    {
        padList.push_back(pad.first);
        padList.push_back(pad.second);
    }

    auto flatBufferDescriptor =
        CreateSpaceToBatchNdDescriptor(m_flatBufferBuilder,
                                       m_flatBufferBuilder.CreateVector(spaceToBatchNdDescriptor.m_BlockShape),
                                       m_flatBufferBuilder.CreateVector(padList),
                                       GetFlatBufferDataLayout(spaceToBatchNdDescriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateSpaceToBatchNdLayer(m_flatBufferBuilder,
                                                                 flatBufferBaseLayer,
                                                                 flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_SpaceToBatchNdLayer);
}

VisitSpaceToDepthLayer()

void VisitSpaceToDepthLayer ( const armnn::IConnectableLayer *  layer, const armnn::SpaceToDepthDescriptor &  spaceToDepthDescriptor, const char *  name = nullptr  )

overridevirtual

Function a space to depth layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
spaceToDepthDescriptor	- Parameters for the space to depth operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1072 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), SpaceToDepthDescriptor::m_BlockSize, and SpaceToDepthDescriptor::m_DataLayout.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToDepth);
    auto flatBufferDescriptor =
        CreateSpaceToDepthDescriptor(m_flatBufferBuilder,
                                     spaceToDepthDescriptor.m_BlockSize,
                                     GetFlatBufferDataLayout(spaceToDepthDescriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateSpaceToDepthLayer(m_flatBufferBuilder,
                                                               flatBufferBaseLayer,
                                                               flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_SpaceToDepthLayer);
}

VisitSplitterLayer()

void VisitSplitterLayer ( const armnn::IConnectableLayer *  layer, const armnn::ViewsDescriptor &  splitterDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a splitter layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
splitterDescriptor	- ViewsDescriptor to configure the splitting process. Number of Views must be equal to the number of outputs, and their order must match - e.g. first view corresponds to the first output, second view to the second output, etc....
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1092 of file Serializer.cpp.

References OriginsDescriptor::GetConcatAxis(), OriginsDescriptor::GetNumDimensions(), ViewsDescriptor::GetNumDimensions(), OriginsDescriptor::GetNumViews(), ViewsDescriptor::GetNumViews(), ViewsDescriptor::GetOrigins(), ViewsDescriptor::GetViewOrigin(), ViewsDescriptor::GetViewSizes(), and armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer ViewOrigins
    std::vector<flatbuffers::Offset<UintVector>> flatBufferViewOrigins;
    flatBufferViewOrigins.reserve(viewsDescriptor.GetNumViews());

    for(unsigned int vIdx = 0; vIdx < viewsDescriptor.GetNumViews(); ++vIdx)
    {
        std::vector<uint32_t> viewOrigin;
        viewOrigin.reserve(viewsDescriptor.GetNumDimensions());

        // Copy vector
        for(unsigned int dIdx = 0; dIdx < viewsDescriptor.GetNumDimensions(); ++dIdx)
        {
            viewOrigin.push_back(viewsDescriptor.GetViewOrigin(vIdx)[dIdx]);
        }

        flatBufferViewOrigins.push_back(CreateUintVector(m_flatBufferBuilder,
                                                         m_flatBufferBuilder.CreateVector(viewOrigin)));
    }

    // Create FlatBuffer OriginsDescriptor
    auto flatBufferOriginDescriptor = CreateOriginsDescriptor(m_flatBufferBuilder,
                                                              viewsDescriptor.GetOrigins().GetConcatAxis(),
                                                              viewsDescriptor.GetOrigins().GetNumViews(),
                                                              viewsDescriptor.GetOrigins().GetNumDimensions(),
                                                              m_flatBufferBuilder.CreateVector(flatBufferViewOrigins));

    // Create FlatBuffer ViewOrigins
    std::vector<flatbuffers::Offset<UintVector>> flatBufferViewSizes;
    flatBufferViewSizes.reserve(viewsDescriptor.GetNumViews());

    for(unsigned int vIdx = 0; vIdx < viewsDescriptor.GetNumViews(); ++vIdx)
    {
        std::vector<uint32_t> viewSize;
        viewSize.reserve(viewsDescriptor.GetNumDimensions());

        // Copy vector
        for(unsigned int dIdx = 0; dIdx < viewsDescriptor.GetNumDimensions(); ++dIdx)
        {
            viewSize.push_back(viewsDescriptor.GetViewSizes(vIdx)[dIdx]);
        }

        flatBufferViewSizes.push_back(CreateUintVector(m_flatBufferBuilder,
                                                       m_flatBufferBuilder.CreateVector(viewSize)));
    }

    // Create FlatBuffer ViewsDescriptor
    auto flatBufferViewsDescriptor = CreateViewsDescriptor(m_flatBufferBuilder,
                                                           flatBufferOriginDescriptor,
                                                           m_flatBufferBuilder.CreateVector(flatBufferViewSizes));

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Splitter);

    auto flatBufferSplitterLayer = serializer::CreateSplitterLayer(m_flatBufferBuilder,
                                                                   flatBufferBaseLayer,
                                                                   flatBufferViewsDescriptor);

    CreateAnyLayer(flatBufferSplitterLayer.o, serializer::Layer::Layer_SplitterLayer);
}

VisitStackLayer()

void VisitStackLayer ( const armnn::IConnectableLayer *  layer, const armnn::StackDescriptor &  stackDescriptor, const char *  name = nullptr  )

overridevirtual

Function a stack layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
stackDescriptor	- Parameters for the stack operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1183 of file Serializer.cpp.

References TensorShape::GetNumDimensions(), armnn::IgnoreUnused(), StackDescriptor::m_Axis, StackDescriptor::m_InputShape, and StackDescriptor::m_NumInputs.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto stackBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Stack);

    std::vector<unsigned int> inputShape;
    for (unsigned int i =0; i < stackDescriptor.m_InputShape.GetNumDimensions(); i++)
    {
        inputShape.push_back(stackDescriptor.m_InputShape[i]);
    }

    auto flatBufferStackDescriptor = CreateStackDescriptor(m_flatBufferBuilder,
                                                           stackDescriptor.m_Axis,
                                                           stackDescriptor.m_NumInputs,
                                                           m_flatBufferBuilder.CreateVector(inputShape));

    auto stackLayer = serializer::CreateStackLayer(m_flatBufferBuilder, stackBaseLayer, flatBufferStackDescriptor);
    CreateAnyLayer(stackLayer.o, serializer::Layer::Layer_StackLayer);
}

VisitStandInLayer()

void VisitStandInLayer ( const armnn::IConnectableLayer *  layer, const armnn::StandInDescriptor &  standInDescriptor, const char *  name = nullptr  )

overridevirtual

Function a StandInLayer should call back to when its Accept(ILaterVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
standInDescriptor	- Parameters for the stand-in layer.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1206 of file Serializer.cpp.

References armnn::IgnoreUnused(), StandInDescriptor::m_NumInputs, and StandInDescriptor::m_NumOutputs.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbDescriptor = serializer::CreateStandInDescriptor(m_flatBufferBuilder,
                                                            standInDescriptor.m_NumInputs,
                                                            standInDescriptor.m_NumOutputs);

    auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StandIn);
    auto fbLayer     = serializer::CreateStandInLayer(m_flatBufferBuilder, fbBaseLayer, fbDescriptor);

    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_StandInLayer);
}

VisitStridedSliceLayer()

void VisitStridedSliceLayer ( const armnn::IConnectableLayer *  layer, const armnn::StridedSliceDescriptor &  stridedSliceDescriptor, const char *  name = nullptr  )

overridevirtual

Function a strided slice layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
stridedSliceDescriptor	- Parameters for the strided slice operation.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1222 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), armnn::IgnoreUnused(), StridedSliceDescriptor::m_Begin, StridedSliceDescriptor::m_BeginMask, StridedSliceDescriptor::m_DataLayout, StridedSliceDescriptor::m_EllipsisMask, StridedSliceDescriptor::m_End, StridedSliceDescriptor::m_EndMask, StridedSliceDescriptor::m_NewAxisMask, StridedSliceDescriptor::m_ShrinkAxisMask, and StridedSliceDescriptor::m_Stride.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StridedSlice);

    auto flatBufferDescriptor =
        CreateStridedSliceDescriptor(m_flatBufferBuilder,
                                     m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_Begin),
                                     m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_End),
                                     m_flatBufferBuilder.CreateVector(stridedSliceDescriptor.m_Stride),
                                     stridedSliceDescriptor.m_BeginMask,
                                     stridedSliceDescriptor.m_EndMask,
                                     stridedSliceDescriptor.m_ShrinkAxisMask,
                                     stridedSliceDescriptor.m_EllipsisMask,
                                     stridedSliceDescriptor.m_NewAxisMask,
                                     GetFlatBufferDataLayout(stridedSliceDescriptor.m_DataLayout));

    auto flatBufferLayer = serializer::CreateStridedSliceLayer(m_flatBufferBuilder,
                                                               flatBufferBaseLayer,
                                                               flatBufferDescriptor);

    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_StridedSliceLayer);
}

VisitSubtractionLayer()

void VisitSubtractionLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a subtraction layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1249 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbSubtractionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Subtraction);
    auto fbSubtractionLayer = serializer::CreateSubtractionLayer(m_flatBufferBuilder, fbSubtractionBaseLayer);

    CreateAnyLayer(fbSubtractionLayer.o, serializer::Layer::Layer_SubtractionLayer);
}

VisitSwitchLayer()

void VisitSwitchLayer ( const armnn::IConnectableLayer *  layer, const char *  name = nullptr  )

overridevirtual

Function a switch layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1259 of file Serializer.cpp.

References armnn::IgnoreUnused().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbSwitchBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Switch);
    auto fbSwitchLayer = serializer::CreateSwitchLayer(m_flatBufferBuilder, fbSwitchBaseLayer);

    CreateAnyLayer(fbSwitchLayer.o, serializer::Layer::Layer_SwitchLayer);
}

VisitTransposeConvolution2dLayer()

void VisitTransposeConvolution2dLayer ( const armnn::IConnectableLayer *  layer, const armnn::TransposeConvolution2dDescriptor &  descriptor, const armnn::ConstTensor &  weights, const armnn::Optional< armnn::ConstTensor > &  biases, const char *  name = nullptr  )

overridevirtual

Function that a 2D transpose convolution layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
descriptor	- Description of the 2D transpose convolution layer.
weights	- Tensor for the weights data.
biases	- Optional tensor for the bias data.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1269 of file Serializer.cpp.

References armnnSerializer::GetFlatBufferDataLayout(), OptionalBase::has_value(), armnn::IgnoreUnused(), TransposeConvolution2dDescriptor::m_BiasEnabled, TransposeConvolution2dDescriptor::m_DataLayout, TransposeConvolution2dDescriptor::m_PadBottom, TransposeConvolution2dDescriptor::m_PadLeft, TransposeConvolution2dDescriptor::m_PadRight, TransposeConvolution2dDescriptor::m_PadTop, TransposeConvolution2dDescriptor::m_StrideX, TransposeConvolution2dDescriptor::m_StrideY, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    auto fbBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
    auto fbDescriptor = CreateTransposeConvolution2dDescriptor(m_flatBufferBuilder,
                                                               descriptor.m_PadLeft,
                                                               descriptor.m_PadRight,
                                                               descriptor.m_PadTop,
                                                               descriptor.m_PadBottom,
                                                               descriptor.m_StrideX,
                                                               descriptor.m_StrideY,
                                                               descriptor.m_BiasEnabled,
                                                               GetFlatBufferDataLayout(descriptor.m_DataLayout));

    // weights & biases
    auto fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
    flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
    if (biases.has_value())
    {
        fbBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
    }

    auto fbLayer = CreateTransposeConvolution2dLayer(m_flatBufferBuilder,
                                                     fbBaseLayer,
                                                     fbDescriptor,
                                                     fbWeightsConstTensorInfo,
                                                     fbBiasesConstTensorInfo);

    CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_TransposeConvolution2dLayer);
}

VisitTransposeLayer()

void VisitTransposeLayer ( const armnn::IConnectableLayer *  layer, const armnn::TransposeDescriptor &  transposeDescriptor, const char *  name = nullptr  )

overridevirtual

Function that a transpose layer should call back to when its Accept(ILayerVisitor&) function is invoked.

Parameters

layer	- pointer to the layer which is calling back to this visit function.
transposeDescriptor	- TransposeDescriptor to configure the transpose.
name	- Optional name for the layer.

Implements ILayerVisitor.

Definition at line 1306 of file Serializer.cpp.

References PermutationVector::GetSize(), armnn::IgnoreUnused(), and TransposeDescriptor::m_DimMappings.

Referenced by SerializerVisitor::GetSerializedLayers().

{
    IgnoreUnused(name);

    // Create FlatBuffer BaseLayer
    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Transpose);

    std::vector<unsigned int> dimMappings;
    for (unsigned int i=0; i<descriptor.m_DimMappings.GetSize(); ++i)
    {
        dimMappings.push_back(descriptor.m_DimMappings[i]);
    }

    auto flatBufferDesc = serializer::CreateTransposeDescriptor(m_flatBufferBuilder,
                                                                m_flatBufferBuilder.CreateVector(dimMappings));

    // Create the FlatBuffer TransposeLayer
    auto flatBufferLayer = serializer::CreateTransposeLayer(m_flatBufferBuilder,
                                                            flatBufferBaseLayer,
                                                            flatBufferDesc);

    // Add the AnyLayer to the FlatBufferLayers
    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_TransposeLayer);
}

---

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

• src/armnnSerializer/Serializer.hpp
• src/armnnSerializer/Serializer.cpp