NetworkImpl Class Reference

Private implementation of INetwork. More...

#include <Network.hpp>

Public Member Functions
	NetworkImpl (const NetworkOptions &networkOptions={})
	~NetworkImpl ()
const Graph &	GetGraph () const
Status	PrintGraph ()
IConnectableLayer *	AddInputLayer (LayerBindingId id, const char *name=nullptr)
IConnectableLayer *	AddActivationLayer (const ActivationDescriptor &activationDescriptor, const char *name=nullptr)
IConnectableLayer *	AddAdditionLayer (const char *name=nullptr)
IConnectableLayer *	AddArgMinMaxLayer (const ArgMinMaxDescriptor &desc, const char *name=nullptr)
IConnectableLayer *	AddBatchMatMulLayer (const BatchMatMulDescriptor &desc, const char *name=nullptr)
IConnectableLayer *	AddBatchNormalizationLayer (const BatchNormalizationDescriptor &desc, const ConstTensor &mean, const ConstTensor &variance, const ConstTensor &beta, const ConstTensor &gamma, const char *name=nullptr)
IConnectableLayer *	AddBatchToSpaceNdLayer (const BatchToSpaceNdDescriptor &batchToSpaceNdDescriptor, const char *name=nullptr)
IConnectableLayer *	AddBroadcastToLayer (const BroadcastToDescriptor &descriptor, const char *name=nullptr)
IConnectableLayer *	AddCastLayer (const char *name=nullptr)
IConnectableLayer *	AddChannelShuffleLayer (const ChannelShuffleDescriptor &channelShuffleDescriptor, const char *name=nullptr)
IConnectableLayer *	AddComparisonLayer (const ComparisonDescriptor &comparisonDescriptor, const char *name=nullptr)
IConnectableLayer *	AddConcatLayer (const ConcatDescriptor &concatDescriptor, const char *name=nullptr)
IConnectableLayer *	AddConvolution2dLayer (const Convolution2dDescriptor &convolution2dDescriptor, const char *name=nullptr)
IConnectableLayer *	AddConvolution3dLayer (const Convolution3dDescriptor &convolution3dDescriptor, const char *name=nullptr)
IConnectableLayer *	AddConstantLayer (const ConstTensor &input, const char *name=nullptr)
IConnectableLayer *	AddDepthToSpaceLayer (const DepthToSpaceDescriptor &depthToSpaceDescriptor, const char *name=nullptr)
IConnectableLayer *	AddDepthwiseConvolution2dLayer (const DepthwiseConvolution2dDescriptor &convolution2dDescriptor, const char *name=nullptr)
IConnectableLayer *	AddDequantizeLayer (const char *name=nullptr)
IConnectableLayer *	AddDetectionPostProcessLayer (const DetectionPostProcessDescriptor &descriptor, const ConstTensor &anchors, const char *name=nullptr)
IConnectableLayer *	AddDivisionLayer (const char *name=nullptr)
IConnectableLayer *	AddElementwiseBinaryLayer (const ElementwiseBinaryDescriptor &elementwiseBinaryDescriptor, const char *name=nullptr)
IConnectableLayer *	AddElementwiseUnaryLayer (const ElementwiseUnaryDescriptor &elementwiseUnaryDescriptor, const char *name=nullptr)
IConnectableLayer *	AddMergeLayer (const char *name=nullptr)
IConnectableLayer *	AddFillLayer (const FillDescriptor &fillDescriptor, const char *name=nullptr)
IConnectableLayer *	AddFloorLayer (const char *name=nullptr)
IConnectableLayer *	AddFullyConnectedLayer (const FullyConnectedDescriptor &fullyConnectedDescriptor, const char *name=nullptr)
IConnectableLayer *	AddFusedLayer (const FusedDescriptor &fusedDescriptor, const char *name=nullptr)
IConnectableLayer *	AddGatherLayer (const GatherDescriptor &gatherDescriptor, const char *name=nullptr)
IConnectableLayer *	AddGatherNdLayer (const char *name=nullptr)
IConnectableLayer *	AddInstanceNormalizationLayer (const InstanceNormalizationDescriptor &desc, const char *name=nullptr)
IConnectableLayer *	AddL2NormalizationLayer (const L2NormalizationDescriptor &desc, const char *name=nullptr)
IConnectableLayer *	AddLogSoftmaxLayer (const LogSoftmaxDescriptor &logSoftmaxDescriptor, const char *name=nullptr)
IConnectableLayer *	AddLogicalBinaryLayer (const LogicalBinaryDescriptor &logicalBinaryDescriptor, const char *name=nullptr)
IConnectableLayer *	AddLstmLayer (const LstmDescriptor &descriptor, const LstmInputParams &params, const char *name=nullptr)
IConnectableLayer *	AddMaximumLayer (const char *name=nullptr)
IConnectableLayer *	AddMeanLayer (const MeanDescriptor &meanDescriptor, const char *name=nullptr)
IConnectableLayer *	AddMinimumLayer (const char *name=nullptr)
IConnectableLayer *	AddMultiplicationLayer (const char *name=nullptr)
IConnectableLayer *	AddNormalizationLayer (const NormalizationDescriptor &normalizationDescriptor, const char *name=nullptr)
IConnectableLayer *	AddOutputLayer (LayerBindingId id, const char *name=nullptr)
IConnectableLayer *	AddPadLayer (const PadDescriptor &padDescriptor, const char *name=nullptr)
IConnectableLayer *	AddPermuteLayer (const PermuteDescriptor &permuteDescriptor, const char *name=nullptr)
IConnectableLayer *	AddPooling2dLayer (const Pooling2dDescriptor &pooling2dDescriptor, const char *name=nullptr)
IConnectableLayer *	AddPooling3dLayer (const Pooling3dDescriptor &pooling3dDescriptor, const char *name=nullptr)
IConnectableLayer *	AddPrecompiledLayer (const PreCompiledDescriptor &preCompiledDescriptor, CompiledBlobPtr compiledBlobPtr, const Optional< BackendId > &backend, const char *name=nullptr)
IConnectableLayer *	AddPreluLayer (const char *name=nullptr)
IConnectableLayer *	AddQuantizeLayer (const char *name=nullptr)
IConnectableLayer *	AddQLstmLayer (const QLstmDescriptor &descriptor, const LstmInputParams &params, const char *name=nullptr)
IConnectableLayer *	AddQuantizedLstmLayer (const QuantizedLstmInputParams &params, const char *name=nullptr)
IConnectableLayer *	AddRankLayer (const char *name=nullptr)
IConnectableLayer *	AddReduceLayer (const ReduceDescriptor &reduceDescriptor, const char *name=nullptr)
IConnectableLayer *	AddResizeLayer (const ResizeDescriptor &resizeDescriptor, const char *name=nullptr)
IConnectableLayer *	AddReshapeLayer (const ReshapeDescriptor &reshapeDescriptor, const char *name=nullptr)
IConnectableLayer *	AddReverseV2Layer (const char *name=nullptr)
IConnectableLayer *	AddShapeLayer (const char *name=nullptr)
IConnectableLayer *	AddSliceLayer (const SliceDescriptor &sliceDescriptor, const char *name=nullptr)
IConnectableLayer *	AddSoftmaxLayer (const SoftmaxDescriptor &softmaxDescriptor, const char *name=nullptr)
IConnectableLayer *	AddSplitterLayer (const ViewsDescriptor &splitterDescriptor, const char *name=nullptr)
IConnectableLayer *	AddSpaceToBatchNdLayer (const SpaceToBatchNdDescriptor &spaceToBatchNdDescriptor, const char *name=nullptr)
IConnectableLayer *	AddSpaceToDepthLayer (const SpaceToDepthDescriptor &spaceToDepthDescriptor, const char *name=nullptr)
IConnectableLayer *	AddStackLayer (const StackDescriptor &stackDescriptor, const char *name=nullptr)
IConnectableLayer *	AddStandInLayer (const StandInDescriptor &descriptor, const char *name=nullptr)
IConnectableLayer *	AddStridedSliceLayer (const StridedSliceDescriptor &stridedSliceDescriptor, const char *name=nullptr)
IConnectableLayer *	AddSubtractionLayer (const char *name=nullptr)
IConnectableLayer *	AddSwitchLayer (const char *name=nullptr)
IConnectableLayer *	AddTileLayer (const TileDescriptor &tileDescriptor, const char *name=nullptr)
IConnectableLayer *	AddTransposeConvolution2dLayer (const TransposeConvolution2dDescriptor &descriptor, const ConstTensor &weights, const Optional< ConstTensor > &biases, const char *name=nullptr)
IConnectableLayer *	AddTransposeLayer (const TransposeDescriptor &transposeDescriptor, const char *name=nullptr)
IConnectableLayer *	AddUnidirectionalSequenceLstmLayer (const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParams &params, const char *name=nullptr)
IConnectableLayer *	AddConvertFp16ToFp32Layer (const char *name=nullptr)
IConnectableLayer *	AddConvertFp32ToFp16Layer (const char *name=nullptr)
void	ExecuteStrategy (IStrategy &strategy) const

Detailed Description

Private implementation of INetwork.

Definition at line 32 of file Network.hpp.

Constructor & Destructor Documentation

NetworkImpl()

NetworkImpl

(

const NetworkOptions &

networkOptions = {}

)

Definition at line 2173 of file Network.cpp.

: m_NetworkOptions(networkOptions),
  m_Graph(std::make_unique<Graph>(GetShapeInferenceMethod(), GetAllowExpandedDims()))
{}

~NetworkImpl()

~NetworkImpl

(

)

Definition at line 2178 of file Network.cpp.

{
}

Member Function Documentation

AddActivationLayer()

IConnectableLayer * AddActivationLayer	(	const ActivationDescriptor &	activationDescriptor,
		const char *	name = nullptr
	)

Definition at line 2314 of file Network.cpp.

{
    return m_Graph->AddLayer<ActivationLayer>(activationDescriptor, name);
}

AddAdditionLayer()

IConnectableLayer * AddAdditionLayer

(

const char *

name = nullptr

)

Definition at line 2360 of file Network.cpp.

{
    return m_Graph->AddLayer<AdditionLayer>(name);
}

AddArgMinMaxLayer()

IConnectableLayer * AddArgMinMaxLayer	(	const ArgMinMaxDescriptor &	desc,
		const char *	name = nullptr
	)

Definition at line 2320 of file Network.cpp.

{
    return m_Graph->AddLayer<ArgMinMaxLayer>(argMinMaxDescriptor, name);
}

AddBatchMatMulLayer()

IConnectableLayer * AddBatchMatMulLayer	(	const BatchMatMulDescriptor &	desc,
		const char *	name = nullptr
	)

Definition at line 3035 of file Network.cpp.

{
    return m_Graph->AddLayer<BatchMatMulLayer>(desc, name);
}

AddBatchNormalizationLayer()

IConnectableLayer * AddBatchNormalizationLayer	(	const BatchNormalizationDescriptor &	desc,
		const ConstTensor &	mean,
		const ConstTensor &	variance,
		const ConstTensor &	beta,
		const ConstTensor &	gamma,
		const char *	name = nullptr
	)

Definition at line 2375 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<BatchNormalizationLayer>(desc, name);
 
    layer->m_Mean = std::make_shared<ScopedTensorHandle>(mean);
    layer->m_Variance = std::make_shared<ScopedTensorHandle>(variance);
    layer->m_Beta = std::make_shared<ScopedTensorHandle>(beta);
    layer->m_Gamma = std::make_shared<ScopedTensorHandle>(gamma);
 
    return layer;
}

References BatchNormalizationLayer::m_Mean.

AddBatchToSpaceNdLayer()

IConnectableLayer * AddBatchToSpaceNdLayer	(	const BatchToSpaceNdDescriptor &	batchToSpaceNdDescriptor,
		const char *	name = nullptr
	)

Definition at line 2193 of file Network.cpp.

{
    return m_Graph->AddLayer<BatchToSpaceNdLayer>(batchToSpaceNdDescriptor, name);
}

AddBroadcastToLayer()

IConnectableLayer * AddBroadcastToLayer	(	const BroadcastToDescriptor &	descriptor,
		const char *	name = nullptr
	)

Definition at line 3083 of file Network.cpp.

{
    return m_Graph->AddLayer<BroadcastToLayer>(desc, name);
}

AddCastLayer()

IConnectableLayer * AddCastLayer

(

const char *

name = nullptr

)

Definition at line 2199 of file Network.cpp.

{
    return m_Graph->AddLayer<CastLayer>(name);
}

AddChannelShuffleLayer()

IConnectableLayer * AddChannelShuffleLayer	(	const ChannelShuffleDescriptor &	channelShuffleDescriptor,
		const char *	name = nullptr
	)

Definition at line 2203 of file Network.cpp.

{
    return m_Graph->AddLayer<ChannelShuffleLayer>(channelShuffleDescriptor, name);
}

AddComparisonLayer()

IConnectableLayer * AddComparisonLayer	(	const ComparisonDescriptor &	comparisonDescriptor,
		const char *	name = nullptr
	)

Definition at line 2209 of file Network.cpp.

{
    return m_Graph->AddLayer<ComparisonLayer>(comparisonDescriptor, name);
}

AddConcatLayer()

IConnectableLayer * AddConcatLayer	(	const ConcatDescriptor &	concatDescriptor,
		const char *	name = nullptr
	)

Definition at line 2245 of file Network.cpp.

{
    return m_Graph->AddLayer<ConcatLayer>(concatDescriptor, name);
}

AddConstantLayer()

IConnectableLayer * AddConstantLayer	(	const ConstTensor &	input,
		const char *	name = nullptr
	)

Definition at line 2431 of file Network.cpp.

{
    auto layer = m_Graph->AddLayer<ConstantLayer>(name);
 
    layer->m_LayerOutput = std::make_shared<ScopedTensorHandle>(input);
 
    return layer;
}

References ConstantLayer::m_LayerOutput.

AddConvertFp16ToFp32Layer()

IConnectableLayer * AddConvertFp16ToFp32Layer

(

const char *

name = nullptr

)

Definition at line 2257 of file Network.cpp.

{
    return m_Graph->AddLayer<ConvertFp16ToFp32Layer>(name);
}

AddConvertFp32ToFp16Layer()

IConnectableLayer * AddConvertFp32ToFp16Layer

(

const char *

name = nullptr

)

Definition at line 2262 of file Network.cpp.

{
    return m_Graph->AddLayer<ConvertFp32ToFp16Layer>(name);
}

AddConvolution2dLayer()

IConnectableLayer * AddConvolution2dLayer	(	const Convolution2dDescriptor &	convolution2dDescriptor,
		const char *	name = nullptr
	)

Definition at line 2251 of file Network.cpp.

{
    return m_Graph->AddLayer<Convolution2dLayer>(convolution2dDescriptor, name);
}

AddConvolution3dLayer()

IConnectableLayer * AddConvolution3dLayer	(	const Convolution3dDescriptor &	convolution3dDescriptor,
		const char *	name = nullptr
	)

Definition at line 2267 of file Network.cpp.

{
    return m_Graph->AddLayer<Convolution3dLayer>(convolution3dDescriptor, name);
}

AddDepthToSpaceLayer()

IConnectableLayer * AddDepthToSpaceLayer	(	const DepthToSpaceDescriptor &	depthToSpaceDescriptor,
		const char *	name = nullptr
	)

Definition at line 2273 of file Network.cpp.

{
    return m_Graph->AddLayer<DepthToSpaceLayer>(depthToSpaceDescriptor, name);
}

AddDepthwiseConvolution2dLayer()

IConnectableLayer * AddDepthwiseConvolution2dLayer	(	const DepthwiseConvolution2dDescriptor &	convolution2dDescriptor,
		const char *	name = nullptr
	)

Definition at line 2279 of file Network.cpp.

{
    return m_Graph->AddLayer<DepthwiseConvolution2dLayer>(convolution2dDescriptor, name);
}

AddDequantizeLayer()

IConnectableLayer * AddDequantizeLayer

(

const char *

name = nullptr

)

Definition at line 2629 of file Network.cpp.

{
    return m_Graph->AddLayer<DequantizeLayer>(name);
}

AddDetectionPostProcessLayer()

IConnectableLayer * AddDetectionPostProcessLayer	(	const DetectionPostProcessDescriptor &	descriptor,
		const ConstTensor &	anchors,
		const char *	name = nullptr
	)

Definition at line 2286 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<DetectionPostProcessLayer>(descriptor, name);
 
    layer->m_Anchors = std::make_shared<ScopedTensorHandle>(anchors);
 
    return layer;
}

References DetectionPostProcessLayer::m_Anchors.

AddDivisionLayer()

IConnectableLayer * AddDivisionLayer

(

const char *

name = nullptr

)

Definition at line 2604 of file Network.cpp.

{
    return m_Graph->AddLayer<DivisionLayer>(name);
}

AddElementwiseBinaryLayer()

IConnectableLayer * AddElementwiseBinaryLayer	(	const ElementwiseBinaryDescriptor &	elementwiseBinaryDescriptor,
		const char *	name = nullptr
	)

Definition at line 2215 of file Network.cpp.

{
    return m_Graph->AddLayer<ElementwiseBinaryLayer>(elementwiseBinaryDesc, name);
}

AddElementwiseUnaryLayer()

IConnectableLayer * AddElementwiseUnaryLayer	(	const ElementwiseUnaryDescriptor &	elementwiseUnaryDescriptor,
		const char *	name = nullptr
	)

Definition at line 2221 of file Network.cpp.

{
    return m_Graph->AddLayer<ElementwiseUnaryLayer>(elementwiseUnaryDescriptor, name);
}

AddFillLayer()

IConnectableLayer * AddFillLayer	(	const FillDescriptor &	fillDescriptor,
		const char *	name = nullptr
	)

Definition at line 2227 of file Network.cpp.

{
    return m_Graph->AddLayer<FillLayer>(fillDescriptor, name);
}

AddFloorLayer()

IConnectableLayer * AddFloorLayer

(

const char *

name = nullptr

)

Definition at line 2458 of file Network.cpp.

{
    return m_Graph->AddLayer<FloorLayer>(name);
}

AddFullyConnectedLayer()

IConnectableLayer * AddFullyConnectedLayer	(	const FullyConnectedDescriptor &	fullyConnectedDescriptor,
		const char *	name = nullptr
	)

Definition at line 2233 of file Network.cpp.

{
    return m_Graph->AddLayer<FullyConnectedLayer>(fullyConnectedDescriptor, name);
}

AddFusedLayer()

IConnectableLayer * AddFusedLayer	(	const FusedDescriptor &	fusedDescriptor,
		const char *	name = nullptr
	)

Definition at line 2239 of file Network.cpp.

{
    return m_Graph->AddLayer<FusedLayer>(fusedDescriptor, name);
}

AddGatherLayer()

IConnectableLayer * AddGatherLayer	(	const GatherDescriptor &	gatherDescriptor,
		const char *	name = nullptr
	)

Definition at line 2640 of file Network.cpp.

{
    return m_Graph->AddLayer<GatherLayer>(gatherDescriptor, name);
}

AddGatherNdLayer()

IConnectableLayer * AddGatherNdLayer

(

const char *

name = nullptr

)

Definition at line 2646 of file Network.cpp.

{
    return m_Graph->AddLayer<GatherNdLayer>(name);
}

AddInputLayer()

IConnectableLayer * AddInputLayer	(	LayerBindingId	id,
		const char *	name = nullptr
	)

Definition at line 2188 of file Network.cpp.

{
    return m_Graph->AddLayer<InputLayer>(id, name);
}

AddInstanceNormalizationLayer()

IConnectableLayer * AddInstanceNormalizationLayer	(	const InstanceNormalizationDescriptor &	desc,
		const char *	name = nullptr
	)

Definition at line 2413 of file Network.cpp.

{
    return m_Graph->AddLayer<InstanceNormalizationLayer>(desc, name);
}

AddL2NormalizationLayer()

IConnectableLayer * AddL2NormalizationLayer	(	const L2NormalizationDescriptor &	desc,
		const char *	name = nullptr
	)

Definition at line 2419 of file Network.cpp.

{
    return m_Graph->AddLayer<L2NormalizationLayer>(desc, name);
}

AddLogicalBinaryLayer()

IConnectableLayer * AddLogicalBinaryLayer	(	const LogicalBinaryDescriptor &	logicalBinaryDescriptor,
		const char *	name = nullptr
	)

Definition at line 2887 of file Network.cpp.

{
    return m_Graph->AddLayer<LogicalBinaryLayer>(logicalBinaryDescriptor, name);
}

AddLogSoftmaxLayer()

IConnectableLayer * AddLogSoftmaxLayer	(	const LogSoftmaxDescriptor &	logSoftmaxDescriptor,
		const char *	name = nullptr
	)

Definition at line 2425 of file Network.cpp.

{
    return m_Graph->AddLayer<LogSoftmaxLayer>(desc, name);
}

AddLstmLayer()

IConnectableLayer * AddLstmLayer	(	const LstmDescriptor &	descriptor,
		const LstmInputParams &	params,
		const char *	name = nullptr
	)

Definition at line 2463 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<LstmLayer>(descriptor, name);
 
    //Lstm Basic Parameters
    layer->m_BasicParameters.m_InputToForgetWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToForgetWeights));
    layer->m_BasicParameters.m_InputToCellWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToCellWeights));
    layer->m_BasicParameters.m_InputToOutputWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToOutputWeights));
    layer->m_BasicParameters.m_RecurrentToForgetWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToForgetWeights));
    layer->m_BasicParameters.m_RecurrentToCellWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToCellWeights));
    layer->m_BasicParameters.m_RecurrentToOutputWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToOutputWeights));
    layer->m_BasicParameters.m_ForgetGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_ForgetGateBias));
    layer->m_BasicParameters.m_CellBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellBias));
    layer->m_BasicParameters.m_OutputGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_OutputGateBias));
 
    //Lstm Cifg parameters
    if(!descriptor.m_CifgEnabled)
    {
        if(params.m_InputToInputWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Input To Input Weights cannot be NULL "
                                           "when CIFG is disabled.");
        }
        if(params.m_RecurrentToInputWeights == nullptr)
        {
            throw InvalidArgumentException(
                    "AddLstmLayer: Recurrent To Input Weights cannot be NULL "
                    "when CIFG is disabled.");
        }
        if(params.m_InputGateBias == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Input Gate Bias cannot be NULL "
                                           "when CIFG is disabled.");
        }
        layer->m_CifgParameters.m_InputToInputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputToInputWeights));
        layer->m_CifgParameters.m_RecurrentToInputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToInputWeights));
        layer->m_CifgParameters.m_InputGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputGateBias));
    }
 
    //Lstm projection parameters
    if(descriptor.m_ProjectionEnabled)
    {
        if(params.m_ProjectionWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Projection Weights cannot be NULL "
                                           "when projection is enabled.");
        }
        layer->m_ProjectionParameters.m_ProjectionWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionWeights));
        if(params.m_ProjectionBias != nullptr)
        {
            layer->m_ProjectionParameters.m_ProjectionBias =
                std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionBias));
        }
    }
 
    //Lstm Peephole params
    if(descriptor.m_PeepholeEnabled)
    {
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_CellToInputWeights == nullptr)
            {
                throw InvalidArgumentException("AddLstmLayer: Cell To Input Weights cannot be NULL "
                                               "when Peephole is enabled and CIFG disabled.");
            }
 
            layer->m_PeepholeParameters.m_CellToInputWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellToInputWeights));
        }
 
        if(params.m_CellToForgetWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Cell To Forget Weights cannot be NULL "
                                           "when Peephole is enabled.");
        }
        if(params.m_CellToOutputWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Cell To Output Weights cannot be NULL "
                                           "when Peephole is enabled.");
        }
 
        layer->m_PeepholeParameters.m_CellToForgetWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellToForgetWeights));
        layer->m_PeepholeParameters.m_CellToOutputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellToOutputWeights));
    }
 
    //Lstm Layer Normalization params
    if(descriptor.m_LayerNormEnabled)
    {
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_InputLayerNormWeights == nullptr)
            {
                throw InvalidArgumentException("AddLstmLayer: Input layer normalization weights cannot be NULL "
                                               "when layer normalization is enabled and CIFG disabled.");
            }
            layer->m_LayerNormParameters.m_InputLayerNormWeights =
                    std::make_shared<ScopedTensorHandle>(*(params.m_InputLayerNormWeights));
        }
 
        if(params.m_ForgetLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Forget layer normalization weights cannot be NULL "
                                           "when layer normalization is enabled.");
        }
        if(params.m_CellLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Cell layer normalization weights cannot be NULL "
                                           "when layer normalization is enabled.");
        }
        if(params.m_OutputLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddLstmLayer: Output layer normalization weights cannot be NULL "
                                           "when layer normalization is enabled.");
        }
        layer->m_LayerNormParameters.m_ForgetLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_ForgetLayerNormWeights));
        layer->m_LayerNormParameters.m_CellLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellLayerNormWeights));
        layer->m_LayerNormParameters.m_OutputLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_OutputLayerNormWeights));
    }
    return layer;
}

References LstmLayer::m_BasicParameters, LstmInputParams::m_CellBias, LstmInputParams::m_CellLayerNormWeights, LstmInputParams::m_CellToForgetWeights, LstmInputParams::m_CellToInputWeights, LstmInputParams::m_CellToOutputWeights, LstmInputParams::m_ForgetGateBias, LstmInputParams::m_ForgetLayerNormWeights, LstmInputParams::m_InputGateBias, LstmInputParams::m_InputLayerNormWeights, LstmInputParams::m_InputToCellWeights, LstmInputParams::m_InputToForgetWeights, LstmBasicParameters::m_InputToForgetWeights, LstmInputParams::m_InputToInputWeights, LstmInputParams::m_InputToOutputWeights, LstmInputParams::m_OutputGateBias, LstmInputParams::m_OutputLayerNormWeights, LstmInputParams::m_ProjectionBias, LstmInputParams::m_ProjectionWeights, LstmInputParams::m_RecurrentToCellWeights, LstmInputParams::m_RecurrentToForgetWeights, LstmInputParams::m_RecurrentToInputWeights, and LstmInputParams::m_RecurrentToOutputWeights.

AddMaximumLayer()

IConnectableLayer * AddMaximumLayer

(

const char *

name = nullptr

)

Definition at line 2350 of file Network.cpp.

{
    return m_Graph->AddLayer<MaximumLayer>(name);
}

AddMeanLayer()

IConnectableLayer * AddMeanLayer	(	const MeanDescriptor &	meanDescriptor,
		const char *	name = nullptr
	)

Definition at line 2614 of file Network.cpp.

{
    return m_Graph->AddLayer<MeanLayer>(meanDescriptor,name);
}

AddMergeLayer()

IConnectableLayer * AddMergeLayer

(

const char *

name = nullptr

)

Definition at line 2651 of file Network.cpp.

{
    return m_Graph->AddLayer<MergeLayer>(name);
}

AddMinimumLayer()

IConnectableLayer * AddMinimumLayer

(

const char *

name = nullptr

)

Definition at line 2355 of file Network.cpp.

{
    return m_Graph->AddLayer<MinimumLayer>(name);
}

AddMultiplicationLayer()

IConnectableLayer * AddMultiplicationLayer

(

const char *

name = nullptr

)

Definition at line 2365 of file Network.cpp.

{
    return m_Graph->AddLayer<MultiplicationLayer>(name);
}

AddNormalizationLayer()

IConnectableLayer * AddNormalizationLayer	(	const NormalizationDescriptor &	normalizationDescriptor,
		const char *	name = nullptr
	)

Definition at line 2326 of file Network.cpp.

{
    return m_Graph->AddLayer<NormalizationLayer>(normalizationDescriptor, name);
}

AddOutputLayer()

IConnectableLayer * AddOutputLayer	(	LayerBindingId	id,
		const char *	name = nullptr
	)

Definition at line 2370 of file Network.cpp.

{
    return m_Graph->AddLayer<OutputLayer>(id, name);
}

AddPadLayer()

IConnectableLayer * AddPadLayer	(	const PadDescriptor &	padDescriptor,
		const char *	name = nullptr
	)

Definition at line 2619 of file Network.cpp.

{
    return m_Graph->AddLayer<PadLayer>(padDescriptor,name);
}

AddPermuteLayer()

IConnectableLayer * AddPermuteLayer	(	const PermuteDescriptor &	permuteDescriptor,
		const char *	name = nullptr
	)

Definition at line 2296 of file Network.cpp.

{
    return m_Graph->AddLayer<PermuteLayer>(permuteDescriptor, name);
}

AddPooling2dLayer()

IConnectableLayer * AddPooling2dLayer	(	const Pooling2dDescriptor &	pooling2dDescriptor,
		const char *	name = nullptr
	)

Definition at line 2302 of file Network.cpp.

{
    return m_Graph->AddLayer<Pooling2dLayer>(pooling2dDescriptor, name);
}

AddPooling3dLayer()

IConnectableLayer * AddPooling3dLayer	(	const Pooling3dDescriptor &	pooling3dDescriptor,
		const char *	name = nullptr
	)

Definition at line 2308 of file Network.cpp.

{
    return m_Graph->AddLayer<Pooling3dLayer>(pooling3dDescriptor, name);
}

AddPrecompiledLayer()

IConnectableLayer * AddPrecompiledLayer	(	const PreCompiledDescriptor &	preCompiledDescriptor,
		CompiledBlobPtr	compiledBlobPtr,
		const Optional< BackendId > &	backend,
		const char *	name = nullptr
	)

Definition at line 3050 of file Network.cpp.

{
    // Method use is for backend users.
    PreCompiledLayer* layer;
    if (name)
    {
        layer = m_Graph->AddLayer<PreCompiledLayer>(preCompiledDescriptor, name);
    }
    else
    {
        layer = m_Graph->AddLayer<PreCompiledLayer>(preCompiledDescriptor, "pre-compiled");
    }
 
    // Assign the pre-compiled object to layer
    // Pass only one compiled network, Arm NN does not handle multiple
    // pre-compiled objects in a single pre-compiled layer currently
    layer->SetPreCompiledObject(std::move(compiledBlobPtr));
 
    if (backend.has_value())
    {
        layer->SetBackendId(backend.value());
    }
    else if (layer->GetBackendHint().has_value())
    {
        layer->SetBackendId(layer->GetBackendHint().value());
    }
 
    return layer;
}

References Layer::GetBackendHint(), OptionalBase::has_value(), Layer::SetBackendId(), PreCompiledLayer::SetPreCompiledObject(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

AddPreluLayer()

IConnectableLayer * AddPreluLayer

(

const char *

name = nullptr

)

Definition at line 2661 of file Network.cpp.

{
    return m_Graph->AddLayer<PreluLayer>(name);
}

AddQLstmLayer()

IConnectableLayer * AddQLstmLayer	(	const QLstmDescriptor &	descriptor,
		const LstmInputParams &	params,
		const char *	name = nullptr
	)

Definition at line 2745 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<QLstmLayer>(descriptor, name);
 
    // QLstm Basic Parameters
    layer->m_BasicParameters.m_InputToForgetWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputToForgetWeights));
    layer->m_BasicParameters.m_InputToCellWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputToCellWeights));
    layer->m_BasicParameters.m_InputToOutputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputToOutputWeights));
    layer->m_BasicParameters.m_RecurrentToForgetWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToForgetWeights));
    layer->m_BasicParameters.m_RecurrentToCellWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToCellWeights));
    layer->m_BasicParameters.m_RecurrentToOutputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToOutputWeights));
    layer->m_BasicParameters.m_ForgetGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_ForgetGateBias));
    layer->m_BasicParameters.m_CellBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellBias));
    layer->m_BasicParameters.m_OutputGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_OutputGateBias));
 
    // QLstm Cifg parameters
    if(!descriptor.m_CifgEnabled)
    {
        if(params.m_InputToInputWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Input To Input Weights cannot be NULL");
        }
 
        if(params.m_RecurrentToInputWeights == nullptr)
        {
            throw InvalidArgumentException(
                    "AddQLstmLayer: Recurrent To Input Weights cannot be NULL");
        }
 
        if(params.m_InputGateBias == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Input Gate Bias cannot be NULL");
        }
 
        layer->m_CifgParameters.m_InputToInputWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_InputToInputWeights));
        layer->m_CifgParameters.m_RecurrentToInputWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToInputWeights));
        layer->m_CifgParameters.m_InputGateBias =
                std::make_shared<ScopedTensorHandle>(*(params.m_InputGateBias));
    }
 
    // QLstm Projection parameters
    if(descriptor.m_ProjectionEnabled)
    {
        if(params.m_ProjectionWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Projection Weights cannot be NULL");
        }
 
        layer->m_ProjectionParameters.m_ProjectionWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionWeights));
 
        // Projection bias is optional even if projection is enabled
        if(params.m_ProjectionBias != nullptr)
        {
            layer->m_ProjectionParameters.m_ProjectionBias =
                    std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionBias));
        }
 
    }
 
    // QLstm Peephole params
    if(descriptor.m_PeepholeEnabled)
    {
        if(params.m_CellToForgetWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Cell To Forget Weights cannot be NULL");
        }
 
        if(params.m_CellToOutputWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Cell To Output Weights cannot be NULL");
        }
 
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_CellToInputWeights == nullptr)
            {
                throw InvalidArgumentException("AddQLstmLayer: Cell To Input Weights cannot be NULL");
            }
 
            layer->m_PeepholeParameters.m_CellToInputWeights =
                    std::make_shared<ScopedTensorHandle>(*(params.m_CellToInputWeights));
        }
 
        layer->m_PeepholeParameters.m_CellToForgetWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellToForgetWeights));
        layer->m_PeepholeParameters.m_CellToOutputWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellToOutputWeights));
    }
 
    // QLstm Layer Normalization params
    if(descriptor.m_LayerNormEnabled)
    {
        if(params.m_ForgetLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Forget layer normalization weights cannot be NULL");
        }
 
        if(params.m_CellLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Cell layer normalization weights cannot be NULL");
        }
 
        if(params.m_OutputLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddQLstmLayer: Output layer normalization weights cannot be NULL");
        }
 
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_InputLayerNormWeights == nullptr)
            {
                throw InvalidArgumentException("AddQLstmLayer: Input layer normalization weights cannot be NULL");
            }
 
            layer->m_LayerNormParameters.m_InputLayerNormWeights =
                    std::make_shared<ScopedTensorHandle>(*(params.m_InputLayerNormWeights));
        }
 
        layer->m_LayerNormParameters.m_ForgetLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_ForgetLayerNormWeights));
        layer->m_LayerNormParameters.m_CellLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellLayerNormWeights));
        layer->m_LayerNormParameters.m_OutputLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_OutputLayerNormWeights));
    }
    return layer;
}

References QLstmLayer::m_BasicParameters, LstmInputParams::m_CellBias, LstmInputParams::m_CellLayerNormWeights, LstmInputParams::m_CellToForgetWeights, LstmInputParams::m_CellToInputWeights, LstmInputParams::m_CellToOutputWeights, LstmInputParams::m_ForgetGateBias, LstmInputParams::m_ForgetLayerNormWeights, LstmInputParams::m_InputGateBias, LstmInputParams::m_InputLayerNormWeights, LstmInputParams::m_InputToCellWeights, QLstmBasicParameters::m_InputToForgetWeights, LstmInputParams::m_InputToForgetWeights, LstmInputParams::m_InputToInputWeights, LstmInputParams::m_InputToOutputWeights, LstmInputParams::m_OutputGateBias, LstmInputParams::m_OutputLayerNormWeights, LstmInputParams::m_ProjectionBias, LstmInputParams::m_ProjectionWeights, LstmInputParams::m_RecurrentToCellWeights, LstmInputParams::m_RecurrentToForgetWeights, LstmInputParams::m_RecurrentToInputWeights, and LstmInputParams::m_RecurrentToOutputWeights.

AddQuantizedLstmLayer()

IConnectableLayer * AddQuantizedLstmLayer	(	const QuantizedLstmInputParams &	params,
		const char *	name = nullptr
	)

Definition at line 2707 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<QuantizedLstmLayer>(name);
 
    // InputToX weights
    layer->m_QuantizedLstmParameters.m_InputToInputWeights =
            std::make_shared<ScopedTensorHandle>(params.GetInputToInputWeights());
    layer->m_QuantizedLstmParameters.m_InputToForgetWeights =
            std::make_shared<ScopedTensorHandle>(params.GetInputToForgetWeights());
    layer->m_QuantizedLstmParameters.m_InputToCellWeights =
            std::make_shared<ScopedTensorHandle>(params.GetInputToCellWeights());
    layer->m_QuantizedLstmParameters.m_InputToOutputWeights =
            std::make_shared<ScopedTensorHandle>(params.GetInputToOutputWeights());
 
    // RecurrentToX weights
    layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights =
            std::make_shared<ScopedTensorHandle>(params.GetRecurrentToInputWeights());
    layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights =
            std::make_shared<ScopedTensorHandle>(params.GetRecurrentToForgetWeights());
    layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights =
            std::make_shared<ScopedTensorHandle>(params.GetRecurrentToCellWeights());
    layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights =
            std::make_shared<ScopedTensorHandle>(params.GetRecurrentToOutputWeights());
 
    // Bias
    layer->m_QuantizedLstmParameters.m_InputGateBias =
            std::make_shared<ScopedTensorHandle>(params.GetInputGateBias());
    layer->m_QuantizedLstmParameters.m_ForgetGateBias =
            std::make_shared<ScopedTensorHandle>(params.GetForgetGateBias());
    layer->m_QuantizedLstmParameters.m_CellBias =
            std::make_shared<ScopedTensorHandle>(params.GetCellBias());
    layer->m_QuantizedLstmParameters.m_OutputGateBias =
            std::make_shared<ScopedTensorHandle>(params.GetOutputGateBias());
 
    return layer;
}

References QuantizedLstmInputParams::GetCellBias(), QuantizedLstmInputParams::GetForgetGateBias(), QuantizedLstmInputParams::GetInputGateBias(), QuantizedLstmInputParams::GetInputToCellWeights(), QuantizedLstmInputParams::GetInputToForgetWeights(), QuantizedLstmInputParams::GetInputToInputWeights(), QuantizedLstmInputParams::GetInputToOutputWeights(), QuantizedLstmInputParams::GetOutputGateBias(), QuantizedLstmInputParams::GetRecurrentToCellWeights(), QuantizedLstmInputParams::GetRecurrentToForgetWeights(), QuantizedLstmInputParams::GetRecurrentToInputWeights(), QuantizedLstmInputParams::GetRecurrentToOutputWeights(), QuantizedLstmParameters::m_InputToInputWeights, and QuantizedLstmLayer::m_QuantizedLstmParameters.

AddQuantizeLayer()

IConnectableLayer * AddQuantizeLayer

(

const char *

name = nullptr

)

Definition at line 2624 of file Network.cpp.

{
    return m_Graph->AddLayer<QuantizeLayer>(name);
}

AddRankLayer()

IConnectableLayer * AddRankLayer

(

const char *

name = nullptr

)

Definition at line 2392 of file Network.cpp.

{
    return m_Graph->AddLayer<RankLayer>(name);
}

AddReduceLayer()

IConnectableLayer * AddReduceLayer	(	const ReduceDescriptor &	reduceDescriptor,
		const char *	name = nullptr
	)

Definition at line 2397 of file Network.cpp.

{
    return m_Graph->AddLayer<ReduceLayer>(reduceDescriptor, name);
}

AddReshapeLayer()

IConnectableLayer * AddReshapeLayer	(	const ReshapeDescriptor &	reshapeDescriptor,
		const char *	name = nullptr
	)

Definition at line 2440 of file Network.cpp.

{
    return m_Graph->AddLayer<ReshapeLayer>(reshapeDescriptor, name);
}

AddResizeLayer()

IConnectableLayer * AddResizeLayer	(	const ResizeDescriptor &	resizeDescriptor,
		const char *	name = nullptr
	)

Definition at line 2403 of file Network.cpp.

{
    return m_Graph->AddLayer<ResizeLayer>(resizeDescriptor, name);
}

AddReverseV2Layer()

IConnectableLayer * AddReverseV2Layer

(

const char *

name = nullptr

)

Definition at line 3040 of file Network.cpp.

{
    return m_Graph->AddLayer<ReverseV2Layer>(name);
}

AddShapeLayer()

IConnectableLayer * AddShapeLayer

(

const char *

name = nullptr

)

Definition at line 2408 of file Network.cpp.

{
    return m_Graph->AddLayer<ShapeLayer>(name);
}

AddSliceLayer()

IConnectableLayer * AddSliceLayer	(	const SliceDescriptor &	sliceDescriptor,
		const char *	name = nullptr
	)

Definition at line 2333 of file Network.cpp.

{
    return m_Graph->AddLayer<SliceLayer>(sliceDescriptor, name);
}

AddSoftmaxLayer()

IConnectableLayer * AddSoftmaxLayer	(	const SoftmaxDescriptor &	softmaxDescriptor,
		const char *	name = nullptr
	)

Definition at line 2338 of file Network.cpp.

{
    return m_Graph->AddLayer<SoftmaxLayer>(softmaxDescriptor, name);
}

AddSpaceToBatchNdLayer()

IConnectableLayer * AddSpaceToBatchNdLayer	(	const SpaceToBatchNdDescriptor &	spaceToBatchNdDescriptor,
		const char *	name = nullptr
	)

Definition at line 2446 of file Network.cpp.

{
    return m_Graph->AddLayer<SpaceToBatchNdLayer>(spaceToBatchNdDescriptor, name);
}

AddSpaceToDepthLayer()

IConnectableLayer * AddSpaceToDepthLayer	(	const SpaceToDepthDescriptor &	spaceToDepthDescriptor,
		const char *	name = nullptr
	)

Definition at line 2452 of file Network.cpp.

{
    return m_Graph->AddLayer<SpaceToDepthLayer>(spaceToDepthDescriptor, name);
}

AddSplitterLayer()

IConnectableLayer * AddSplitterLayer	(	const ViewsDescriptor &	splitterDescriptor,
		const char *	name = nullptr
	)

Definition at line 2344 of file Network.cpp.

{
    return m_Graph->AddLayer<SplitterLayer>(splitterDescriptor, name);
}

AddStackLayer()

IConnectableLayer * AddStackLayer	(	const StackDescriptor &	stackDescriptor,
		const char *	name = nullptr
	)

Definition at line 2694 of file Network.cpp.

{
    return m_Graph->AddLayer<StackLayer>(stackDescriptor, name);
}

AddStandInLayer()

IConnectableLayer * AddStandInLayer	(	const StandInDescriptor &	descriptor,
		const char *	name = nullptr
	)

Definition at line 2701 of file Network.cpp.

{
    return m_Graph->AddLayer<StandInLayer>(desc, name);
}

AddStridedSliceLayer()

IConnectableLayer * AddStridedSliceLayer	(	const StridedSliceDescriptor &	stridedSliceDescriptor,
		const char *	name = nullptr
	)

Definition at line 2634 of file Network.cpp.

{
    return m_Graph->AddLayer<StridedSliceLayer>(stridedSliceDescriptor, name);
}

AddSubtractionLayer()

IConnectableLayer * AddSubtractionLayer

(

const char *

name = nullptr

)

Definition at line 2609 of file Network.cpp.

{
    return m_Graph->AddLayer<SubtractionLayer>(name);
}

AddSwitchLayer()

IConnectableLayer * AddSwitchLayer

(

const char *

name = nullptr

)

Definition at line 2656 of file Network.cpp.

{
    return m_Graph->AddLayer<SwitchLayer>(name);
}

AddTileLayer()

IConnectableLayer * AddTileLayer	(	const TileDescriptor &	tileDescriptor,
		const char *	name = nullptr
	)

Definition at line 3045 of file Network.cpp.

{
    return m_Graph->AddLayer<TileLayer>(desc, name);
}

AddTransposeConvolution2dLayer()

IConnectableLayer * AddTransposeConvolution2dLayer	(	const TransposeConvolution2dDescriptor &	descriptor,
		const ConstTensor &	weights,
		const Optional< ConstTensor > &	biases,
		const char *	name = nullptr
	)

Definition at line 2666 of file Network.cpp.

{
    if (descriptor.m_BiasEnabled && !biases.has_value())
    {
        throw InvalidArgumentException("AddTransposeConvolution2dLayer: Biases cannot be empty");
    }
 
    const auto layer = m_Graph->AddLayer<TransposeConvolution2dLayer>(descriptor, name);
 
    layer->m_Weight = std::make_shared<ScopedTensorHandle>(weights);
 
    if (descriptor.m_BiasEnabled)
    {
        layer->m_Bias = std::make_shared<ScopedTensorHandle>(biases.value());
    }
 
    return layer;
}

References OptionalBase::has_value(), TransposeConvolution2dDescriptor::m_BiasEnabled, TransposeConvolution2dLayer::m_Weight, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

AddTransposeLayer()

IConnectableLayer * AddTransposeLayer	(	const TransposeDescriptor &	transposeDescriptor,
		const char *	name = nullptr
	)

Definition at line 2688 of file Network.cpp.

{
    return m_Graph->AddLayer<TransposeLayer>(transposeDescriptor, name);
}

AddUnidirectionalSequenceLstmLayer()

IConnectableLayer * AddUnidirectionalSequenceLstmLayer	(	const UnidirectionalSequenceLstmDescriptor &	descriptor,
		const LstmInputParams &	params,
		const char *	name = nullptr
	)

Definition at line 2893 of file Network.cpp.

{
    const auto layer = m_Graph->AddLayer<UnidirectionalSequenceLstmLayer>(descriptor, name);
 
    //Lstm Basic Parameters
    layer->m_BasicParameters.m_InputToForgetWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToForgetWeights));
    layer->m_BasicParameters.m_InputToCellWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToCellWeights));
    layer->m_BasicParameters.m_InputToOutputWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_InputToOutputWeights));
    layer->m_BasicParameters.m_RecurrentToForgetWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToForgetWeights));
    layer->m_BasicParameters.m_RecurrentToCellWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToCellWeights));
    layer->m_BasicParameters.m_RecurrentToOutputWeights =
        std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToOutputWeights));
    layer->m_BasicParameters.m_ForgetGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_ForgetGateBias));
    layer->m_BasicParameters.m_CellBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellBias));
    layer->m_BasicParameters.m_OutputGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_OutputGateBias));
 
    //Lstm Cifg parameters
    if(!descriptor.m_CifgEnabled)
    {
        if(params.m_InputToInputWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Input To Input Weights cannot be NULL "
                                           "when CIFG is disabled.");
        }
        if(params.m_RecurrentToInputWeights == nullptr)
        {
            throw InvalidArgumentException(
                    "AddUnidirectionalSequenceLstmLayer: Recurrent To Input Weights cannot be NULL "
                    "when CIFG is disabled.");
        }
        if(params.m_InputGateBias == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Input Gate Bias cannot be NULL "
                                           "when CIFG is disabled.");
        }
        layer->m_CifgParameters.m_InputToInputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputToInputWeights));
        layer->m_CifgParameters.m_RecurrentToInputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_RecurrentToInputWeights));
        layer->m_CifgParameters.m_InputGateBias =
            std::make_shared<ScopedTensorHandle>(*(params.m_InputGateBias));
    }
 
    //Lstm projection parameters
    if(descriptor.m_ProjectionEnabled)
    {
        if(params.m_ProjectionWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Projection Weights cannot be NULL "
                                           "when projection is enabled.");
        }
        layer->m_ProjectionParameters.m_ProjectionWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionWeights));
        if(params.m_ProjectionBias != nullptr)
        {
            layer->m_ProjectionParameters.m_ProjectionBias =
                std::make_shared<ScopedTensorHandle>(*(params.m_ProjectionBias));
        }
    }
 
    //Lstm Peephole params
    if(descriptor.m_PeepholeEnabled)
    {
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_CellToInputWeights == nullptr)
            {
                throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Cell To Input Weights "
                                               "cannot be NULL when Peephole is enabled and CIFG disabled.");
            }
 
            layer->m_PeepholeParameters.m_CellToInputWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellToInputWeights));
        }
 
        if(params.m_CellToForgetWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Cell To Forget Weights cannot be NULL "
                                           "when Peephole is enabled.");
        }
        if(params.m_CellToOutputWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Cell To Output Weights cannot be NULL "
                                           "when Peephole is enabled.");
        }
 
        layer->m_PeepholeParameters.m_CellToForgetWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellToForgetWeights));
        layer->m_PeepholeParameters.m_CellToOutputWeights =
            std::make_shared<ScopedTensorHandle>(*(params.m_CellToOutputWeights));
    }
 
    //Lstm Layer Normalization params
    if(descriptor.m_LayerNormEnabled)
    {
        if(!descriptor.m_CifgEnabled)
        {
            if(params.m_InputLayerNormWeights == nullptr)
            {
                throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Input layer normalization weights "
                                               "cannot be NULL when layer normalization is enabled and CIFG disabled.");
            }
            layer->m_LayerNormParameters.m_InputLayerNormWeights =
                    std::make_shared<ScopedTensorHandle>(*(params.m_InputLayerNormWeights));
        }
 
        if(params.m_ForgetLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Forget layer normalization weights "
                                           "cannot be NULL when layer normalization is enabled.");
        }
        if(params.m_CellLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Cell layer normalization weights "
                                           "cannot be NULL when layer normalization is enabled.");
        }
        if(params.m_OutputLayerNormWeights == nullptr)
        {
            throw InvalidArgumentException("AddUnidirectionalSequenceLstmLayer: Output layer normalization weights "
                                           "cannot be NULL when layer normalization is enabled.");
        }
        layer->m_LayerNormParameters.m_ForgetLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_ForgetLayerNormWeights));
        layer->m_LayerNormParameters.m_CellLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_CellLayerNormWeights));
        layer->m_LayerNormParameters.m_OutputLayerNormWeights =
                std::make_shared<ScopedTensorHandle>(*(params.m_OutputLayerNormWeights));
    }
    return layer;
}

References UnidirectionalSequenceLstmLayer::m_BasicParameters, LstmInputParams::m_CellBias, LstmInputParams::m_CellLayerNormWeights, LstmInputParams::m_CellToForgetWeights, LstmInputParams::m_CellToInputWeights, LstmInputParams::m_CellToOutputWeights, LstmInputParams::m_ForgetGateBias, LstmInputParams::m_ForgetLayerNormWeights, LstmInputParams::m_InputGateBias, LstmInputParams::m_InputLayerNormWeights, LstmInputParams::m_InputToCellWeights, LstmInputParams::m_InputToForgetWeights, LstmBasicParameters::m_InputToForgetWeights, LstmInputParams::m_InputToInputWeights, LstmInputParams::m_InputToOutputWeights, LstmInputParams::m_OutputGateBias, LstmInputParams::m_OutputLayerNormWeights, LstmInputParams::m_ProjectionBias, LstmInputParams::m_ProjectionWeights, LstmInputParams::m_RecurrentToCellWeights, LstmInputParams::m_RecurrentToForgetWeights, LstmInputParams::m_RecurrentToInputWeights, and LstmInputParams::m_RecurrentToOutputWeights.

ExecuteStrategy()

void ExecuteStrategy

(

IStrategy &

strategy

)

const

Definition at line 3088 of file Network.cpp.

{
    for (auto layer : GetGraph())
    {
        layer->ExecuteStrategy(strategy);
    };
}

References NetworkImpl::GetGraph().

GetGraph()

const Graph& GetGraph ( ) const

inline

Definition at line 38 of file Network.hpp.

    { return *m_Graph; }

Referenced by NetworkImpl::ExecuteStrategy().

PrintGraph()

Status PrintGraph

(

)

Definition at line 2182 of file Network.cpp.

{
    m_Graph->Print();
    return Status::Success;
}

References armnn::Success.

---

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

• src/armnn/Network.hpp
• src/armnn/Network.cpp