ArmNN
 24.08
UnidirectionalSequenceLstmQueueDescriptor Struct Reference

#include <WorkloadData.hpp>

Inheritance diagram for UnidirectionalSequenceLstmQueueDescriptor:
[legend]
Collaboration diagram for UnidirectionalSequenceLstmQueueDescriptor:
[legend]

Public Member Functions

 UnidirectionalSequenceLstmQueueDescriptor ()
 
void Validate (const WorkloadInfo &workloadInfo) const
 
- Public Member Functions inherited from QueueDescriptorWithParameters< LstmDescriptor >
virtual ~QueueDescriptorWithParameters ()=default
 
- Public Member Functions inherited from QueueDescriptor
virtual ~QueueDescriptor ()=default
 
void ValidateTensorNumDimensions (const TensorInfo &tensor, std::string const &descName, unsigned int numDimensions, std::string const &tensorName) const
 
void ValidateTensorNumDimNumElem (const TensorInfo &tensorInfo, unsigned int numDimension, unsigned int numElements, std::string const &tensorName) const
 
void ValidateInputsOutputs (const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const
 
template<typename T >
const T * GetAdditionalInformation () const
 

Public Attributes

const ConstTensorHandlem_InputToInputWeights
 
const ConstTensorHandlem_InputToForgetWeights
 
const ConstTensorHandlem_InputToCellWeights
 
const ConstTensorHandlem_InputToOutputWeights
 
const ConstTensorHandlem_RecurrentToInputWeights
 
const ConstTensorHandlem_RecurrentToForgetWeights
 
const ConstTensorHandlem_RecurrentToCellWeights
 
const ConstTensorHandlem_RecurrentToOutputWeights
 
const ConstTensorHandlem_CellToInputWeights
 
const ConstTensorHandlem_CellToForgetWeights
 
const ConstTensorHandlem_CellToOutputWeights
 
const ConstTensorHandlem_InputGateBias
 
const ConstTensorHandlem_ForgetGateBias
 
const ConstTensorHandlem_CellBias
 
const ConstTensorHandlem_OutputGateBias
 
const ConstTensorHandlem_ProjectionWeights
 
const ConstTensorHandlem_ProjectionBias
 
const ConstTensorHandlem_InputLayerNormWeights
 
const ConstTensorHandlem_ForgetLayerNormWeights
 
const ConstTensorHandlem_CellLayerNormWeights
 
const ConstTensorHandlem_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
 
bool m_AllowExpandedDims = false
 

Additional Inherited Members

- Protected Member Functions inherited from QueueDescriptorWithParameters< LstmDescriptor >
 QueueDescriptorWithParameters ()=default
 
 QueueDescriptorWithParameters (QueueDescriptorWithParameters const &)=default
 
QueueDescriptorWithParametersoperator= (QueueDescriptorWithParameters const &)=default
 
- Protected Member Functions inherited from QueueDescriptor
 QueueDescriptor ()
 
 QueueDescriptor (QueueDescriptor const &)=default
 
QueueDescriptoroperator= (QueueDescriptor const &)=default
 

Detailed Description

Definition at line 696 of file WorkloadData.hpp.

Constructor & Destructor Documentation

◆ UnidirectionalSequenceLstmQueueDescriptor()

Definition at line 698 of file WorkloadData.hpp.

699  : m_InputToInputWeights(nullptr)
700  , m_InputToForgetWeights(nullptr)
701  , m_InputToCellWeights(nullptr)
702  , m_InputToOutputWeights(nullptr)
703  , m_RecurrentToInputWeights(nullptr)
704  , m_RecurrentToForgetWeights(nullptr)
705  , m_RecurrentToCellWeights(nullptr)
706  , m_RecurrentToOutputWeights(nullptr)
707  , m_CellToInputWeights(nullptr)
708  , m_CellToForgetWeights(nullptr)
709  , m_CellToOutputWeights(nullptr)
710  , m_InputGateBias(nullptr)
711  , m_ForgetGateBias(nullptr)
712  , m_CellBias(nullptr)
713  , m_OutputGateBias(nullptr)
714  , m_ProjectionWeights(nullptr)
715  , m_ProjectionBias(nullptr)
716  , m_InputLayerNormWeights(nullptr)
717  , m_ForgetLayerNormWeights(nullptr)
718  , m_CellLayerNormWeights(nullptr)
719  , m_OutputLayerNormWeights(nullptr)
720  {
721  }

Member Function Documentation

◆ Validate()

void Validate ( const WorkloadInfo workloadInfo) const

Definition at line 3924 of file WorkloadData.cpp.

3925 {
3926  // Modified from LstmQueueDescriptor::Validate to support UnidirectionalSequenceLstm
3927 
3928  const std::string descriptorName{"UnidirectionalSequenceLstmQueueDescriptor"};
3929 
3930  // check dimensions of all inputs and outputs
3931  if (workloadInfo.m_InputTensorInfos.size() != 3)
3932  {
3933  throw InvalidArgumentException(descriptorName + ": Invalid number of inputs.");
3934  }
3935  if (workloadInfo.m_OutputTensorInfos.size() != 3)
3936  {
3937  throw InvalidArgumentException(descriptorName + ": Invalid number of outputs.");
3938  }
3939 
3940  std::vector<DataType> supportedTypes =
3941  {
3944  };
3945 
3946  // check for supported type of one input and match them with all the other input and output
3947  ValidateDataTypes(workloadInfo.m_InputTensorInfos[0], supportedTypes, descriptorName);
3948 
3949  // Making sure clipping parameters have valid values.
3950  // == 0 means no clipping
3951  // > 0 means clipping
3952  if (m_Parameters.m_ClippingThresCell < 0.0f)
3953  {
3954  throw InvalidArgumentException(descriptorName + ": negative cell clipping threshold is invalid");
3955  }
3956  if (m_Parameters.m_ClippingThresProj < 0.0f)
3957  {
3958  throw InvalidArgumentException(descriptorName + ": negative projection clipping threshold is invalid");
3959  }
3960 
3961  unsigned int batchIndx = 0;
3962  unsigned int inputIndx = 1;
3963  uint32_t timeStep = 1;
3964  unsigned int timeIndx = 1;
3965  inputIndx = 2;
3967  {
3968  batchIndx = 1;
3969  timeIndx = 0;
3970 
3971  }
3972  timeStep = workloadInfo.m_InputTensorInfos[0].GetShape()[timeIndx];
3973 
3974  // Inferring batch size, number of outputs and number of cells from the inputs.
3975  const uint32_t n_input = workloadInfo.m_InputTensorInfos[0].GetShape()[inputIndx];
3976  const uint32_t n_batch = workloadInfo.m_InputTensorInfos[0].GetShape()[batchIndx];
3977  ValidatePointer(m_InputToOutputWeights, "Null pointer check", "InputToOutputWeights");
3978  const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
3979  ValidatePointer(m_RecurrentToOutputWeights, "Null pointer check", "RecurrentToOutputWeights");
3980  const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
3981 
3982  // input tensor
3983  ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[0], 3, (timeStep * n_batch * n_input),
3984  descriptorName + " input_0");
3985  // outputStateInTensor
3986  ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[1], 2, (n_batch * n_output),
3987  descriptorName + " input_1");
3988  // outputStateInTensor
3989  ValidateTensorNumDimNumElem(workloadInfo.m_InputTensorInfos[2], 2, (n_batch * n_cell),
3990  descriptorName + " input_2");
3991 
3992  // outputTensor
3993  ValidateTensorNumDimNumElem(workloadInfo.m_OutputTensorInfos[2], 3, (timeStep * n_batch * n_output),
3994  descriptorName + " output_0");
3995 
3996  // check that dimensions of inputs/outputs and QueueDescriptor data match with each other
3997  if ( m_InputToInputWeights )
3998  {
4000  (n_cell * n_input), "InputLayerNormWeights");
4001  }
4002 
4003  ValidatePointer(m_InputToForgetWeights, "Null pointer check", "InputToForgetWeights");
4005  (n_cell * n_input), "InputToForgetWeights");
4006 
4007  ValidatePointer(m_InputToCellWeights, "Null pointer check", "InputToCellWeights");
4009  (n_cell * n_input), "InputToCellWeights");
4010 
4012  {
4014  (n_cell * n_output), "RecurrentToInputWeights");
4015  }
4016 
4017  ValidatePointer(m_RecurrentToForgetWeights, "Null pointer check", "RecurrentToForgetWeights");
4019  (n_cell * n_output), "RecurrentToForgetWeights");
4020 
4021  ValidatePointer(m_RecurrentToCellWeights, "Null pointer check", "RecurrentToCellWeights");
4023  (n_cell * n_output), "RecurrentToCellWeights");
4024 
4025  // Make sure the input-gate's parameters are either both present (regular
4026  // LSTM) or not at all (CIFG-LSTM). And CifgEnable is set accordingly.
4027  bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
4031  if (!cifg_weights_all_or_none)
4032  {
4033  throw InvalidArgumentException(descriptorName + ": Input-Gate's parameters InputToInputWeights and "
4034  "RecurrentToInputWeights must either both be present (regular LSTM) "
4035  "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
4036  "accordingly.");
4037  }
4038 
4039  if ( m_CellToInputWeights )
4040  {
4042  n_cell, "CellToInputWeights");
4043  }
4044  if ( m_CellToForgetWeights )
4045  {
4047  n_cell, "CellToForgetWeights");
4048  }
4049  if ( m_CellToOutputWeights )
4050  {
4052  n_cell, "CellToOutputWeights");
4053  }
4054 
4055  // Making sure the peephole weights are there all or none. And PeepholeEnable is set accordingly.
4056  bool peephole_weights_all_or_none =
4061  if (!peephole_weights_all_or_none)
4062  {
4063  throw InvalidArgumentException(descriptorName + ": Invalid combination of peephole parameters.");
4064  }
4065 
4066  // Make sure the input gate bias is present only when not a CIFG-LSTM.
4068  {
4069  if (m_InputGateBias)
4070  {
4071  throw InvalidArgumentException(descriptorName + ": InputGateBias is present and CIFG-LSTM is enabled.");
4072  }
4073  }
4074  else
4075  {
4076  if (!m_InputGateBias)
4077  {
4078  throw InvalidArgumentException(descriptorName + ": If CIFG-LSTM is disabled InputGateBias "
4079  "must be present.");
4080  }
4082  n_cell, "InputGateBias");
4083  }
4084 
4085  ValidatePointer(m_ForgetGateBias, "Null pointer check", "ForgetGateBias");
4086  ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell, "ForgetGateBias");
4087 
4088  ValidatePointer(m_CellBias, "Null pointer check", "CellBias");
4089  ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell, "CellBias");
4090 
4091  ValidatePointer(m_OutputGateBias, "Null pointer check", "OutputGateBias");
4092  ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell, "OutputGateBias");
4093 
4094  if (m_ProjectionWeights)
4095  {
4097  (n_cell * n_output), "ProjectionWeights");
4098  }
4099  if (m_ProjectionBias)
4100  {
4101  ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output, "ProjectionBias");
4102  }
4103 
4104  // Making sure the projection tensors are consistent:
4105  // 1) If projection weight is not present, then projection bias should not be
4106  // present.
4107  // 2) If projection weight is present, then projection bias is optional.
4108  bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
4114  if (!projecton_tensors_consistent)
4115  {
4116  throw InvalidArgumentException(descriptorName + ": Projection tensors are inconsistent.");
4117  }
4118 
4119  // The four layer normalization weights either all have values or none of them have values. Additionally, if
4120  // CIFG is used, input layer normalization weights tensor is omitted and the other layer normalization weights
4121  // either all have values or none of them have values. Layer normalization is used when the values of all the
4122  // layer normalization weights are present
4124  {
4125  ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell, "InputLayerNormWeights");
4126  }
4128  {
4129  ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell, "ForgetLayerNormWeights");
4130  }
4132  {
4133  ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell, "CellLayerNormWeights");
4134  }
4136  {
4137  ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell, "OutputLayerNormWeights");
4138  }
4139 
4141  {
4143  {
4145  {
4146  throw InvalidArgumentException(descriptorName + ": Layer normalisation is enabled and CIFG-LSTM is "
4147  "disabled but InputLayerNormWeights are not present");
4148  }
4150  1, n_cell, "InputLayerNormWeights");
4151  }
4152  else if (m_InputLayerNormWeights)
4153  {
4154  throw InvalidArgumentException(descriptorName + ":InputLayerNormWeights are present while CIFG is "
4155  "enabled");
4156  }
4157 
4158  ValidatePointer(m_ForgetLayerNormWeights, "Null pointer check layer normalisation enabled",
4159  "ForgetLayerNormWeights");
4160  ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell, "ForgetLayerNormWeights");
4161 
4162  ValidatePointer(m_OutputLayerNormWeights, "Null pointer check layer normalisation enabled",
4163  "OutputLayerNormWeights");
4164  ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell, "OutputLayerNormWeights");
4165 
4166  ValidatePointer(m_CellLayerNormWeights, "Null pointer check layer normalisation enabled",
4167  "CellLayerNormWeights");
4168  ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell, "CellLayerNormWeights");
4169  }
4171  {
4172  throw InvalidArgumentException(descriptorName + ": Layer normalisation is disabled but one or more layer "
4173  "normalisation weights are present.");
4174  }
4175 }

References armnn::Float32, ConstTensorHandle::GetShape(), ConstTensorHandle::GetTensorInfo(), UnidirectionalSequenceLstmQueueDescriptor::m_CellBias, UnidirectionalSequenceLstmQueueDescriptor::m_CellLayerNormWeights, UnidirectionalSequenceLstmQueueDescriptor::m_CellToForgetWeights, UnidirectionalSequenceLstmQueueDescriptor::m_CellToInputWeights, UnidirectionalSequenceLstmQueueDescriptor::m_CellToOutputWeights, LstmDescriptor::m_CifgEnabled, LstmDescriptor::m_ClippingThresCell, LstmDescriptor::m_ClippingThresProj, UnidirectionalSequenceLstmQueueDescriptor::m_ForgetGateBias, UnidirectionalSequenceLstmQueueDescriptor::m_ForgetLayerNormWeights, UnidirectionalSequenceLstmQueueDescriptor::m_InputGateBias, UnidirectionalSequenceLstmQueueDescriptor::m_InputLayerNormWeights, WorkloadInfo::m_InputTensorInfos, UnidirectionalSequenceLstmQueueDescriptor::m_InputToCellWeights, UnidirectionalSequenceLstmQueueDescriptor::m_InputToForgetWeights, UnidirectionalSequenceLstmQueueDescriptor::m_InputToInputWeights, UnidirectionalSequenceLstmQueueDescriptor::m_InputToOutputWeights, LstmDescriptor::m_LayerNormEnabled, UnidirectionalSequenceLstmQueueDescriptor::m_OutputGateBias, UnidirectionalSequenceLstmQueueDescriptor::m_OutputLayerNormWeights, WorkloadInfo::m_OutputTensorInfos, QueueDescriptorWithParameters< LstmDescriptor >::m_Parameters, LstmDescriptor::m_PeepholeEnabled, UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionBias, LstmDescriptor::m_ProjectionEnabled, UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionWeights, UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToCellWeights, UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToForgetWeights, UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToInputWeights, UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToOutputWeights, LstmDescriptor::m_TimeMajor, armnn::QAsymmS8, and QueueDescriptor::ValidateTensorNumDimNumElem().

Member Data Documentation

◆ m_CellBias

◆ m_CellLayerNormWeights

◆ m_CellToForgetWeights

◆ m_CellToInputWeights

◆ m_CellToOutputWeights

◆ m_ForgetGateBias

◆ m_ForgetLayerNormWeights

◆ m_InputGateBias

◆ m_InputLayerNormWeights

◆ m_InputToCellWeights

◆ m_InputToForgetWeights

◆ m_InputToInputWeights

◆ m_InputToOutputWeights

◆ m_OutputGateBias

◆ m_OutputLayerNormWeights

◆ m_ProjectionBias

◆ m_ProjectionWeights

◆ m_RecurrentToCellWeights

◆ m_RecurrentToForgetWeights

◆ m_RecurrentToInputWeights

◆ m_RecurrentToOutputWeights


The documentation for this struct was generated from the following files:
armnn::ConstTensorHandle::GetShape
TensorShape GetShape() const override
Get the number of elements for each dimension ordered from slowest iterating dimension to fastest ite...
Definition: TensorHandle.hpp:56
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellBias
const ConstTensorHandle * m_CellBias
Definition: WorkloadData.hpp:736
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToCellWeights
const ConstTensorHandle * m_RecurrentToCellWeights
Definition: WorkloadData.hpp:729
armnn::LstmDescriptor::m_TimeMajor
bool m_TimeMajor
Enable/disable time major.
Definition: Descriptors.hpp:1154
armnn::DataType::Float32
@ Float32
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputLayerNormWeights
const ConstTensorHandle * m_InputLayerNormWeights
Definition: WorkloadData.hpp:740
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToOutputWeights
const ConstTensorHandle * m_InputToOutputWeights
Definition: WorkloadData.hpp:726
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_OutputLayerNormWeights
const ConstTensorHandle * m_OutputLayerNormWeights
Definition: WorkloadData.hpp:743
armnn::ConstTensorHandle::GetTensorInfo
const TensorInfo & GetTensorInfo() const
Definition: TensorHandle.hpp:40
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_OutputGateBias
const ConstTensorHandle * m_OutputGateBias
Definition: WorkloadData.hpp:737
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ForgetLayerNormWeights
const ConstTensorHandle * m_ForgetLayerNormWeights
Definition: WorkloadData.hpp:741
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToForgetWeights
const ConstTensorHandle * m_InputToForgetWeights
Definition: WorkloadData.hpp:724
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToOutputWeights
const ConstTensorHandle * m_RecurrentToOutputWeights
Definition: WorkloadData.hpp:730
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionWeights
const ConstTensorHandle * m_ProjectionWeights
Definition: WorkloadData.hpp:738
armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1148
armnn::WorkloadInfo::m_OutputTensorInfos
std::vector< TensorInfo > m_OutputTensorInfos
Definition: WorkloadInfo.hpp:19
armnn::LstmDescriptor::m_ClippingThresProj
float m_ClippingThresProj
Clipping threshold value for the projection.
Definition: Descriptors.hpp:1144
armnn::QueueDescriptorWithParameters< LstmDescriptor >::m_Parameters
LstmDescriptor m_Parameters
Definition: WorkloadData.hpp:66
armnn::InvalidArgumentException
Definition: Exceptions.hpp:80
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ForgetGateBias
const ConstTensorHandle * m_ForgetGateBias
Definition: WorkloadData.hpp:735
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputGateBias
const ConstTensorHandle * m_InputGateBias
Definition: WorkloadData.hpp:734
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToInputWeights
const ConstTensorHandle * m_CellToInputWeights
Definition: WorkloadData.hpp:731
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToOutputWeights
const ConstTensorHandle * m_CellToOutputWeights
Definition: WorkloadData.hpp:733
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToForgetWeights
const ConstTensorHandle * m_RecurrentToForgetWeights
Definition: WorkloadData.hpp:728
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToForgetWeights
const ConstTensorHandle * m_CellToForgetWeights
Definition: WorkloadData.hpp:732
armnn::DataType::QAsymmS8
@ QAsymmS8
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToInputWeights
const ConstTensorHandle * m_RecurrentToInputWeights
Definition: WorkloadData.hpp:727
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToInputWeights
const ConstTensorHandle * m_InputToInputWeights
Definition: WorkloadData.hpp:723
armnn::LstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
Definition: Descriptors.hpp:1146
armnn::LstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:1152
armnn::WorkloadInfo::m_InputTensorInfos
std::vector< TensorInfo > m_InputTensorInfos
Definition: WorkloadInfo.hpp:18
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionBias
const ConstTensorHandle * m_ProjectionBias
Definition: WorkloadData.hpp:739
armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1150
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToCellWeights
const ConstTensorHandle * m_InputToCellWeights
Definition: WorkloadData.hpp:725
armnn::QueueDescriptor::ValidateTensorNumDimNumElem
void ValidateTensorNumDimNumElem(const TensorInfo &tensorInfo, unsigned int numDimension, unsigned int numElements, std::string const &tensorName) const
Definition: WorkloadData.cpp:436
armnn::LstmDescriptor::m_ClippingThresCell
float m_ClippingThresCell
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:1142
armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellLayerNormWeights
const ConstTensorHandle * m_CellLayerNormWeights
Definition: WorkloadData.hpp:742