#include <WorkloadData.hpp>

Inheritance diagram for LstmQueueDescriptor:

Public Member Functions
	LstmQueueDescriptor ()

void	Validate (const WorkloadInfo &workloadInfo) const

Public Member Functions inherited from QueueDescriptor
void	ValidateInputsOutputs (const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const

template<typename T >
const T *	GetAdditionalInformation () const

Public Attributes
const ConstCpuTensorHandle *	m_InputToInputWeights

const ConstCpuTensorHandle *	m_InputToForgetWeights

const ConstCpuTensorHandle *	m_InputToCellWeights

const ConstCpuTensorHandle *	m_InputToOutputWeights

const ConstCpuTensorHandle *	m_RecurrentToInputWeights

const ConstCpuTensorHandle *	m_RecurrentToForgetWeights

const ConstCpuTensorHandle *	m_RecurrentToCellWeights

const ConstCpuTensorHandle *	m_RecurrentToOutputWeights

const ConstCpuTensorHandle *	m_CellToInputWeights

const ConstCpuTensorHandle *	m_CellToForgetWeights

const ConstCpuTensorHandle *	m_CellToOutputWeights

const ConstCpuTensorHandle *	m_InputGateBias

const ConstCpuTensorHandle *	m_ForgetGateBias

const ConstCpuTensorHandle *	m_CellBias

const ConstCpuTensorHandle *	m_OutputGateBias

const ConstCpuTensorHandle *	m_ProjectionWeights

const ConstCpuTensorHandle *	m_ProjectionBias

const ConstCpuTensorHandle *	m_InputLayerNormWeights

const ConstCpuTensorHandle *	m_ForgetLayerNormWeights

const ConstCpuTensorHandle *	m_CellLayerNormWeights

const ConstCpuTensorHandle *	m_OutputLayerNormWeights

Public Attributes inherited from QueueDescriptorWithParameters< LstmDescriptor >
LstmDescriptor	m_Parameters

Public Attributes inherited from QueueDescriptor
std::vector< ITensorHandle * >	m_Inputs

std::vector< ITensorHandle * >	m_Outputs

void *	m_AdditionalInfoObject

Additional Inherited Members
Protected Member Functions inherited from QueueDescriptorWithParameters< LstmDescriptor >
	~QueueDescriptorWithParameters ()=default

	QueueDescriptorWithParameters ()=default

	QueueDescriptorWithParameters (QueueDescriptorWithParameters const &)=default

QueueDescriptorWithParameters &	operator= (QueueDescriptorWithParameters const &)=default

Protected Member Functions inherited from QueueDescriptor
	~QueueDescriptor ()=default

	QueueDescriptor ()

	QueueDescriptor (QueueDescriptor const &)=default

QueueDescriptor &	operator= (QueueDescriptor const &)=default

Detailed Description

Definition at line 387 of file WorkloadData.hpp.

Constructor & Destructor Documentation

◆ LstmQueueDescriptor()

LstmQueueDescriptor ( )

inline

Definition at line 389 of file WorkloadData.hpp.

         : m_InputToInputWeights(nullptr)
         , m_InputToForgetWeights(nullptr)
         , m_InputToCellWeights(nullptr)
         , m_InputToOutputWeights(nullptr)
         , m_RecurrentToInputWeights(nullptr)
         , m_RecurrentToForgetWeights(nullptr)
         , m_RecurrentToCellWeights(nullptr)
         , m_RecurrentToOutputWeights(nullptr)
         , m_CellToInputWeights(nullptr)
         , m_CellToForgetWeights(nullptr)
         , m_CellToOutputWeights(nullptr)
         , m_InputGateBias(nullptr)
         , m_ForgetGateBias(nullptr)
         , m_CellBias(nullptr)
         , m_OutputGateBias(nullptr)
         , m_ProjectionWeights(nullptr)
         , m_ProjectionBias(nullptr)
         , m_InputLayerNormWeights(nullptr)
         , m_ForgetLayerNormWeights(nullptr)
         , m_CellLayerNormWeights(nullptr)
         , m_OutputLayerNormWeights(nullptr)
     {
     }

Member Function Documentation

◆ Validate()

void Validate ( const WorkloadInfo & workloadInfo ) const

Definition at line 1832 of file WorkloadData.cpp.

References armnn::BFloat16, armnn::Float16, armnn::Float32, WorkloadInfo::m_InputTensorInfos, WorkloadInfo::m_OutputTensorInfos, and armnn::QSymmS16.

 {
     // ported from android/ml/nn/common/operations/LSTM.cpp CheckInputTensorDimensions()
 
     const std::string descriptorName{"LstmQueueDescriptor"};
 
     // check dimensions of all inputs and outputs
     if (workloadInfo.m_InputTensorInfos.size() != 3)
     {
         throw InvalidArgumentException(descriptorName + ": Invalid number of inputs.");
     }
     if (workloadInfo.m_OutputTensorInfos.size() != 4)
     {
         throw InvalidArgumentException(descriptorName + ": Invalid number of outputs.");
     }
 
     std::vector<DataType> supportedTypes =
     {
         DataType::BFloat16,
         DataType::Float16,
         DataType::Float32,
         DataType::QSymmS16
     };
 
     // check for supported type of one input and match them with all the other input and output
     ValidateDataTypes(workloadInfo.m_InputTensorInfos[0], supportedTypes, descriptorName);
 
     // type matches all other inputs
     for (uint32_t i = 1u; i < workloadInfo.m_InputTensorInfos.size(); ++i)
     {
         ValidateTensorDataTypesMatch(workloadInfo.m_InputTensorInfos[0],
                                      workloadInfo.m_InputTensorInfos[i],
                                      descriptorName,
                                      "input_0",
                                      "input_" + std::to_string(i));
     }
     // type matches all other outputs
     for (uint32_t i = 0u; i < workloadInfo.m_OutputTensorInfos.size(); ++i)
     {
         ValidateTensorDataTypesMatch(workloadInfo.m_InputTensorInfos[0],
                                      workloadInfo.m_OutputTensorInfos[i],
                                      "LstmQueueDescriptor",
                                      "input_0",
                                      "output_" + std::to_string(i));
     }
 
     // Making sure clipping parameters have valid values.
     // == 0 means no clipping
     //  > 0 means clipping
     if (m_Parameters.m_ClippingThresCell < 0.0f)
     {
         throw InvalidArgumentException(descriptorName + ": negative cell clipping threshold is invalid");
     }
     if (m_Parameters.m_ClippingThresProj < 0.0f)
     {
         throw InvalidArgumentException(descriptorName + ": negative projection clipping threshold is invalid");
     }
 
 
     // Inferring batch size, number of outputs and number of cells from the inputs.
     const uint32_t n_input = workloadInfo.m_InputTensorInfos[0].GetShape()[1];
     const uint32_t n_batch = workloadInfo.m_InputTensorInfos[0].GetShape()[0];
     ValidatePointer(m_InputToOutputWeights, "Null pointer check", "InputToOutputWeights");
     const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
     ValidatePointer(m_RecurrentToOutputWeights, "Null pointer check", "RecurrentToOutputWeights");
     const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
 
     // input tensor
     ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[0], 2, (n_batch * n_input),
                                 descriptorName + " input_0");
     // outputStateInTensor
     ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[1], 2, (n_batch * n_output),
                                 descriptorName + " input_1");
     // outputStateInTensor
     ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[2], 2, (n_batch * n_cell),
                                 descriptorName + " input_2");
     // scratchBufferTensor
     unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
     ValidateTensorNumDimNumElem(workloadInfo.m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
                                 descriptorName + " output_0");
     // outputStateOutTensor
     ValidateTensorNumDimNumElem(workloadInfo.m_OutputTensorInfos[1], 2, (n_batch * n_output),
                                 descriptorName + " output_1");
     // cellStateOutTensor
     ValidateTensorNumDimNumElem(workloadInfo.m_OutputTensorInfos[2], 2, (n_batch * n_cell),
                                 descriptorName + " output_2");
     // outputTensor
     ValidateTensorNumDimNumElem(workloadInfo.m_OutputTensorInfos[3], 2, (n_batch * n_output),
                                 descriptorName + " output_3");
 
 
     // check that dimensions of inputs/outputs and QueueDescriptor data match with each other
     if ( m_InputToInputWeights )
     {
         ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
                                       (n_cell * n_input), "InputLayerNormWeights");
     }
 
     ValidatePointer(m_InputToForgetWeights, "Null pointer check", "InputToForgetWeights");
     ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
                                   (n_cell * n_input), "InputToForgetWeights");
 
     ValidatePointer(m_InputToCellWeights, "Null pointer check", "InputToCellWeights");
     ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
                                   (n_cell * n_input), "InputToCellWeights");
 
     if ( m_RecurrentToInputWeights )
     {
         ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
                                       (n_cell * n_output), "RecurrentToInputWeights");
     }
 
     ValidatePointer(m_RecurrentToForgetWeights, "Null pointer check", "RecurrentToForgetWeights");
     ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
                                   (n_cell * n_output), "RecurrentToForgetWeights");
 
     ValidatePointer(m_RecurrentToCellWeights, "Null pointer check", "RecurrentToCellWeights");
     ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
                                   (n_cell * n_output), "RecurrentToCellWeights");
 
     // Make sure the input-gate's parameters are either both present (regular
     // LSTM) or not at all (CIFG-LSTM). And CifgEnable is set accordingly.
     bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
                                      !m_Parameters.m_CifgEnabled) ||
                                      (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
                                      m_Parameters.m_CifgEnabled));
     if (!cifg_weights_all_or_none)
     {
         throw InvalidArgumentException(descriptorName + ": Input-Gate's parameters InputToInputWeights and "
                                        "RecurrentToInputWeights must either both be present (regular LSTM) "
                                        "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
                                        "accordingly.");
     }
 
     if ( m_CellToInputWeights )
     {
         ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
                                       n_cell, "CellToInputWeights");
     }
     if ( m_CellToForgetWeights )
     {
         ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
                                       n_cell, "CellToForgetWeights");
     }
     if ( m_CellToOutputWeights )
     {
         ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
                                       n_cell, "CellToOutputWeights");
     }
 
     // Making sure the peephole weights are there all or none. And PeepholeEnable is set accordingly.
     bool peephole_weights_all_or_none =
             (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) &&  m_CellToForgetWeights
             && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
             || ( !m_CellToInputWeights && !m_CellToForgetWeights
             && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
     if (!peephole_weights_all_or_none)
     {
         throw InvalidArgumentException(descriptorName + ": Invalid combination of peephole parameters.");
     }
 
     // Make sure the input gate bias is present only when not a CIFG-LSTM.
     if (m_Parameters.m_CifgEnabled)
     {
         if (m_InputGateBias)
         {
             throw InvalidArgumentException(descriptorName + ": InputGateBias is present and CIFG-LSTM is enabled.");
         }
     }
     else
     {
         if (!m_InputGateBias)
         {
             throw InvalidArgumentException(descriptorName + ": If CIFG-LSTM is disabled InputGateBias "
                                            "must be present.");
         }
         ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
                                       n_cell, "InputGateBias");
     }
 
     ValidatePointer(m_ForgetGateBias, "Null pointer check", "ForgetGateBias");
     ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell, "ForgetGateBias");
 
     ValidatePointer(m_CellBias, "Null pointer check", "CellBias");
     ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell, "CellBias");
 
     ValidatePointer(m_OutputGateBias, "Null pointer check", "OutputGateBias");
     ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell, "OutputGateBias");
 
     if (m_ProjectionWeights)
     {
         ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
                                       (n_cell * n_output), "ProjectionWeights");
     }
     if (m_ProjectionBias)
     {
         ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output, "ProjectionBias");
     }
 
     // Making sure the projection tensors are consistent:
     // 1) If projection weight is not present, then projection bias should not be
     // present.
     // 2) If projection weight is present, then projection bias is optional.
     bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
                                         !m_Parameters.m_ProjectionEnabled)
                                         || (m_ProjectionWeights && !m_ProjectionBias &&
                                         m_Parameters.m_ProjectionEnabled)
                                         || (m_ProjectionWeights && m_ProjectionBias &&
                                         m_Parameters.m_ProjectionEnabled));
     if (!projecton_tensors_consistent)
     {
         throw InvalidArgumentException(descriptorName + ": Projection tensors are inconsistent.");
     }
 
     // The four layer normalization weights either all have values or none of them have values. Additionally, if
     // CIFG is used, input layer normalization weights tensor is omitted and the other layer normalization weights
     // either all have values or none of them have values. Layer normalization is used when the values of all the
     // layer normalization weights are present
     if (m_InputLayerNormWeights)
     {
         ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell, "InputLayerNormWeights");
     }
     if (m_ForgetLayerNormWeights)
     {
         ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell, "ForgetLayerNormWeights");
     }
     if (m_CellLayerNormWeights)
     {
         ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell, "CellLayerNormWeights");
     }
     if (m_OutputLayerNormWeights)
     {
         ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell, "OutputLayerNormWeights");
     }
 
     if (m_Parameters.m_LayerNormEnabled)
     {
         if (!m_Parameters.m_CifgEnabled)
         {
             if (!m_InputLayerNormWeights)
             {
                 throw InvalidArgumentException(descriptorName + ": Layer normalisation is enabled and CIFG-LSTM is "
                                                "disabled but InputLayerNormWeights are not present");
             }
             ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
                                           1, n_cell, "InputLayerNormWeights");
         }
         else if (m_InputLayerNormWeights)
         {
             throw InvalidArgumentException(descriptorName + ":InputLayerNormWeights are present while CIFG is "
                                            "enabled");
         }
 
         ValidatePointer(m_ForgetLayerNormWeights, "Null pointer check layer normalisation enabled",
                         "ForgetLayerNormWeights");
         ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell, "ForgetLayerNormWeights");
 
         ValidatePointer(m_OutputLayerNormWeights, "Null pointer check layer normalisation enabled",
                         "OutputLayerNormWeights");
         ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell, "OutputLayerNormWeights");
 
         ValidatePointer(m_CellLayerNormWeights, "Null pointer check layer normalisation enabled",
                         "CellLayerNormWeights");
         ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell, "CellLayerNormWeights");
     }
     else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
     {
         throw InvalidArgumentException(descriptorName + ": Layer normalisation is disabled but one or more layer "
                                        "normalisation weights are present.");
     }
 }