patch/21.08/_unidirectional_sequence_lstm_layer_8cpp_source.xhtml

 //
 // Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #include "UnidirectionalSequenceLstmLayer.hpp"

 #include "LayerCloneBase.hpp"

 #include <armnn/LstmParams.hpp>
 #include <armnn/TypesUtils.hpp>
 #include <backendsCommon/TensorHandle.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>

 namespace armnn
 {

 UnidirectionalSequenceLstmLayer::UnidirectionalSequenceLstmLayer(const LstmDescriptor& param, const char* name)
         : LayerWithParameters(3, 1, LayerType::UnidirectionalSequenceLstm, param, name)
 {
 }

 std::unique_ptr<IWorkload> UnidirectionalSequenceLstmLayer::CreateWorkload(const IWorkloadFactory& factory) const
 {
     UnidirectionalSequenceLstmQueueDescriptor descriptor;

     // Basic parameters
     descriptor.m_InputToForgetWeights = m_BasicParameters.m_InputToForgetWeights.get();
     descriptor.m_InputToCellWeights = m_BasicParameters.m_InputToCellWeights.get();
     descriptor.m_InputToOutputWeights = m_BasicParameters.m_InputToOutputWeights.get();
     descriptor.m_RecurrentToForgetWeights = m_BasicParameters.m_RecurrentToForgetWeights.get();
     descriptor.m_RecurrentToCellWeights = m_BasicParameters.m_RecurrentToCellWeights.get();
     descriptor.m_RecurrentToOutputWeights = m_BasicParameters.m_RecurrentToOutputWeights.get();
     descriptor.m_ForgetGateBias = m_BasicParameters.m_ForgetGateBias.get();
     descriptor.m_CellBias = m_BasicParameters.m_CellBias.get();
     descriptor.m_OutputGateBias = m_BasicParameters.m_OutputGateBias.get();

     // Cifg parameters
     if (!m_Param.m_CifgEnabled)
     {
         descriptor.m_InputToInputWeights = m_CifgParameters.m_InputToInputWeights.get();
         descriptor.m_RecurrentToInputWeights = m_CifgParameters.m_RecurrentToInputWeights.get();
         descriptor.m_InputGateBias = m_CifgParameters.m_InputGateBias.get();
     }

     // Projection parameters
     if (m_Param.m_ProjectionEnabled)
     {
         descriptor.m_ProjectionWeights = m_ProjectionParameters.m_ProjectionWeights.get();
         descriptor.m_ProjectionBias    = m_ProjectionParameters.m_ProjectionBias.get();
     }

     // Peephole parameters
     if (m_Param.m_PeepholeEnabled)
     {
         if (!m_Param.m_CifgEnabled)
         {
             descriptor.m_CellToInputWeights = m_PeepholeParameters.m_CellToInputWeights.get();
         }
         descriptor.m_CellToForgetWeights = m_PeepholeParameters.m_CellToForgetWeights.get();
         descriptor.m_CellToOutputWeights = m_PeepholeParameters.m_CellToOutputWeights.get();
     }

     // Layer normalisation parameters
     if(m_Param.m_LayerNormEnabled)
     {
         if (!m_Param.m_CifgEnabled)
         {
             descriptor.m_InputLayerNormWeights = m_LayerNormParameters.m_InputLayerNormWeights.get();
         }
         descriptor.m_ForgetLayerNormWeights = m_LayerNormParameters.m_ForgetLayerNormWeights.get();
         descriptor.m_CellLayerNormWeights = m_LayerNormParameters.m_CellLayerNormWeights.get();
         descriptor.m_OutputLayerNormWeights = m_LayerNormParameters.m_OutputLayerNormWeights.get();
     }

     SetAdditionalInfo(descriptor);

     return factory.CreateUnidirectionalSequenceLstm(descriptor, PrepInfoAndDesc(descriptor));
 }

 UnidirectionalSequenceLstmLayer* UnidirectionalSequenceLstmLayer::Clone(Graph& graph) const
 {
     auto layer = CloneBase<UnidirectionalSequenceLstmLayer>(graph, m_Param, GetName());

     layer->m_BasicParameters.m_InputToForgetWeights = m_BasicParameters.m_InputToForgetWeights ?
             m_BasicParameters.m_InputToForgetWeights
                 : nullptr;
     layer->m_BasicParameters.m_InputToCellWeights = m_BasicParameters.m_InputToCellWeights ?
             m_BasicParameters.m_InputToCellWeights : nullptr;
     layer->m_BasicParameters.m_InputToOutputWeights = m_BasicParameters.m_InputToOutputWeights ?
             m_BasicParameters.m_InputToOutputWeights : nullptr;
     layer->m_BasicParameters.m_RecurrentToForgetWeights = m_BasicParameters.m_RecurrentToForgetWeights ?
             m_BasicParameters.m_RecurrentToForgetWeights : nullptr;
     layer->m_BasicParameters.m_RecurrentToCellWeights = m_BasicParameters.m_RecurrentToCellWeights ?
             m_BasicParameters.m_RecurrentToCellWeights : nullptr;
     layer->m_BasicParameters.m_RecurrentToOutputWeights = m_BasicParameters.m_RecurrentToOutputWeights ?
             m_BasicParameters.m_RecurrentToOutputWeights : nullptr;
     layer->m_BasicParameters.m_ForgetGateBias = m_BasicParameters.m_ForgetGateBias ?
             m_BasicParameters.m_ForgetGateBias : nullptr;
     layer->m_BasicParameters.m_CellBias = m_BasicParameters.m_CellBias ?
             m_BasicParameters.m_CellBias : nullptr;
     layer->m_BasicParameters.m_OutputGateBias = m_BasicParameters.m_OutputGateBias ?
             m_BasicParameters.m_OutputGateBias : nullptr;

     if (!m_Param.m_CifgEnabled)
     {
         layer->m_CifgParameters.m_InputToInputWeights = m_CifgParameters.m_InputToInputWeights ?
                 m_CifgParameters.m_InputToInputWeights : nullptr;
         layer->m_CifgParameters.m_RecurrentToInputWeights = m_CifgParameters.m_RecurrentToInputWeights ?
                 m_CifgParameters.m_RecurrentToInputWeights : nullptr;
         layer->m_CifgParameters.m_InputGateBias = m_CifgParameters.m_InputGateBias ?
                 m_CifgParameters.m_InputGateBias : nullptr;
     }

     if (m_Param.m_ProjectionEnabled)
     {
         layer->m_ProjectionParameters.m_ProjectionWeights = m_ProjectionParameters.m_ProjectionWeights ?
                m_ProjectionParameters.m_ProjectionWeights : nullptr;
         layer->m_ProjectionParameters.m_ProjectionBias = m_ProjectionParameters.m_ProjectionBias ?
                m_ProjectionParameters.m_ProjectionBias : nullptr;
     }

     if (m_Param.m_PeepholeEnabled)
     {
         if (!m_Param.m_CifgEnabled)
         {
             layer->m_PeepholeParameters.m_CellToInputWeights = m_PeepholeParameters.m_CellToInputWeights ?
                 m_PeepholeParameters.m_CellToInputWeights : nullptr;
         }
         layer->m_PeepholeParameters.m_CellToForgetWeights = m_PeepholeParameters.m_CellToForgetWeights ?
                m_PeepholeParameters.m_CellToForgetWeights : nullptr;
         layer->m_PeepholeParameters.m_CellToOutputWeights = m_PeepholeParameters.m_CellToOutputWeights ?
                m_PeepholeParameters.m_CellToOutputWeights : nullptr;
     }

     if (m_Param.m_LayerNormEnabled)
     {
         layer->m_LayerNormParameters.m_InputLayerNormWeights = m_LayerNormParameters.m_InputLayerNormWeights ?
                m_LayerNormParameters.m_InputLayerNormWeights : nullptr;
         layer->m_LayerNormParameters.m_ForgetLayerNormWeights = m_LayerNormParameters.m_ForgetLayerNormWeights ?
                m_LayerNormParameters.m_ForgetLayerNormWeights : nullptr;
         layer->m_LayerNormParameters.m_CellLayerNormWeights = m_LayerNormParameters.m_CellLayerNormWeights ?
                m_LayerNormParameters.m_CellLayerNormWeights : nullptr;
         layer->m_LayerNormParameters.m_OutputLayerNormWeights = m_LayerNormParameters.m_OutputLayerNormWeights ?
                m_LayerNormParameters.m_OutputLayerNormWeights : nullptr;
     }

     return std::move(layer);
 }

 std::vector<TensorShape> UnidirectionalSequenceLstmLayer::InferOutputShapes(
     const std::vector<TensorShape>& inputShapes) const
 {
     ARMNN_ASSERT(inputShapes.size() == 3);

     // Get input values for validation
     unsigned int outputSize = inputShapes[1][1];

     std::vector<TensorShape> outShapes;
     if (m_Param.m_TimeMajor)
     {
         outShapes.push_back(TensorShape({inputShapes[0][0], inputShapes[0][1], outputSize}));
     }
     else
     {
         outShapes.push_back(TensorShape({inputShapes[0][0], inputShapes[0][1], outputSize}));
     }
     return outShapes;
 }

 void UnidirectionalSequenceLstmLayer::ValidateTensorShapesFromInputs()
 {
     VerifyLayerConnections(3, CHECK_LOCATION());

     const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();

     VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);

     auto inferredShapes = InferOutputShapes( {
         GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(),
         GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape(),
         GetInputSlot(2).GetConnection()->GetTensorInfo().GetShape()
     });

     ARMNN_ASSERT(inferredShapes.size() == 1);

     // Check if the weights are nullptr
     ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToForgetWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_InputToForgetWeights should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToCellWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_InputToCellWeights should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToOutputWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_InputToOutputWeights should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToForgetWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_RecurrentToForgetWeights "
                      "should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToCellWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_RecurrentToCellWeights should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToOutputWeights != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_RecurrentToOutputWeights "
                      "should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_ForgetGateBias != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_ForgetGateBias should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_CellBias != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_CellBias should not be null.");
     ARMNN_ASSERT_MSG(m_BasicParameters.m_OutputGateBias != nullptr,
                      "UnidirectionalSequenceLstmLayer: m_BasicParameters.m_OutputGateBias should not be null.");

     if (!m_Param.m_CifgEnabled)
     {
         ARMNN_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_InputToInputWeights should not be null.");
         ARMNN_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_RecurrentToInputWeights "
                          "should not be null.");
         ARMNN_ASSERT_MSG(m_CifgParameters.m_InputGateBias != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_InputGateBias should not be null.");
     }
     else
     {
         ARMNN_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights == nullptr,
             "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_InputToInputWeights should not have a value "
             "when CIFG is enabled.");
         ARMNN_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights == nullptr,
             "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not have a value "
             "when CIFG is enabled.");
         ARMNN_ASSERT_MSG(m_CifgParameters.m_InputGateBias == nullptr,
             "UnidirectionalSequenceLstmLayer: m_CifgParameters.m_InputGateBias should not have a value "
             "when CIFG is enabled.");
     }

     if (m_Param.m_ProjectionEnabled)
     {
         ARMNN_ASSERT_MSG(m_ProjectionParameters.m_ProjectionWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_ProjectionParameters.m_ProjectionWeights "
                          "should not be null.");
     }

     if (m_Param.m_PeepholeEnabled)
     {
         if (!m_Param.m_CifgEnabled)
         {
             ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToInputWeights != nullptr,
                              "UnidirectionalSequenceLstmLayer: m_PeepholeParameters.m_CellToInputWeights "
                              "should not be null "
                              "when Peephole is enabled and CIFG is disabled.");
         }
         ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToForgetWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_PeepholeParameters.m_CellToForgetWeights "
                          "should not be null.");
         ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToOutputWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_PeepholeParameters.m_CellToOutputWeights "
                          "should not be null.");
     }

     if (m_Param.m_LayerNormEnabled)
     {
         if(!m_Param.m_CifgEnabled)
         {
             ARMNN_ASSERT_MSG(m_LayerNormParameters.m_InputLayerNormWeights != nullptr,
                              "UnidirectionalSequenceLstmLayer: m_LayerNormParameters.m_inputLayerNormWeights "
                              "should not be null.");
         }
         ARMNN_ASSERT_MSG(m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_LayerNormParameters.m_forgetLayerNormWeights "
                          "should not be null.");
         ARMNN_ASSERT_MSG(m_LayerNormParameters.m_CellLayerNormWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_LayerNormParameters.m_cellLayerNormWeights "
                          "should not be null.");
         ARMNN_ASSERT_MSG(m_LayerNormParameters.m_OutputLayerNormWeights != nullptr,
                          "UnidirectionalSequenceLstmLayer: m_LayerNormParameters.m_outputLayerNormWeights "
                          "should not be null.");
     }

     ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "UnidirectionalSequenceLstmLayer");
 }

 Layer::ConstantTensors UnidirectionalSequenceLstmLayer::GetConstantTensorsByRef()
 {
     return {m_BasicParameters.m_InputToForgetWeights,
             m_BasicParameters.m_InputToCellWeights,
             m_BasicParameters.m_InputToOutputWeights,
             m_BasicParameters.m_RecurrentToForgetWeights,
             m_BasicParameters.m_RecurrentToCellWeights,
             m_BasicParameters.m_RecurrentToOutputWeights,
             m_BasicParameters.m_ForgetGateBias,
             m_BasicParameters.m_CellBias,
             m_BasicParameters.m_OutputGateBias,

             // Cifg parameters
             m_CifgParameters.m_InputToInputWeights,
             m_CifgParameters.m_RecurrentToInputWeights,
             m_CifgParameters.m_InputGateBias,

             // Projection parameters
             m_ProjectionParameters.m_ProjectionWeights,
             m_ProjectionParameters.m_ProjectionBias,

             // Peephole parameters
             m_PeepholeParameters.m_CellToInputWeights,
             m_PeepholeParameters.m_CellToForgetWeights,
             m_PeepholeParameters.m_CellToOutputWeights,

             // Layer normalisation parameters
             m_LayerNormParameters.m_InputLayerNormWeights,
             m_LayerNormParameters.m_ForgetLayerNormWeights,
             m_LayerNormParameters.m_CellLayerNormWeights,
             m_LayerNormParameters.m_OutputLayerNormWeights};
 }

 void UnidirectionalSequenceLstmLayer::Accept(ILayerVisitor& visitor) const
 {
     IgnoreUnused(visitor);
     throw armnn::Exception("UnidirectionalSequenceLstmLayer: VisitUnidirectionalSequenceLstmLayer is not implemented");
 }

 void UnidirectionalSequenceLstmLayer::ExecuteStrategy(IStrategy& strategy) const
 {
     std::vector<ConstTensor> constTensors;

     LstmDescriptor descriptor = GetParameters();

     ManagedConstTensorHandle managedInputToForgetWeights(m_BasicParameters.m_InputToForgetWeights);
     ManagedConstTensorHandle managedInputToCellWeights(m_BasicParameters.m_InputToCellWeights);
     ManagedConstTensorHandle managedInputToOutputWeights(m_BasicParameters.m_InputToOutputWeights);
     ManagedConstTensorHandle managedRecurrentToForgetWeights(m_BasicParameters.m_RecurrentToForgetWeights);
     ManagedConstTensorHandle managedRecurrentToCellWeights(m_BasicParameters.m_RecurrentToCellWeights);
     ManagedConstTensorHandle managedRecurrentToOutputWeights(m_BasicParameters.m_RecurrentToOutputWeights);
     ManagedConstTensorHandle managedForgetGateBias(m_BasicParameters.m_ForgetGateBias);
     ManagedConstTensorHandle managedCellBias(m_BasicParameters.m_CellBias);
     ManagedConstTensorHandle managedOutputGateBias(m_BasicParameters.m_OutputGateBias);

     // Cifg parameters
     ManagedConstTensorHandle managedInputToInputWeights(m_CifgParameters.m_InputToInputWeights);
     ManagedConstTensorHandle managedRecurrentToInputWeights(m_CifgParameters.m_RecurrentToInputWeights);
     ManagedConstTensorHandle managedInputGateBias(m_CifgParameters.m_InputGateBias);

     // Projection parameters
     ManagedConstTensorHandle managedProjectionWeights(m_ProjectionParameters.m_ProjectionWeights);
     ManagedConstTensorHandle managedProjectionBias(m_ProjectionParameters.m_ProjectionBias);

     // Peephole parameters
     ManagedConstTensorHandle managedCellToInputWeights(m_PeepholeParameters.m_CellToInputWeights);
     ManagedConstTensorHandle managedCellToForgetWeights(m_PeepholeParameters.m_CellToForgetWeights);
     ManagedConstTensorHandle managedCellToOutputWeights(m_PeepholeParameters.m_CellToOutputWeights);

     // Layer normalisation parameters
     ManagedConstTensorHandle managedInputLayerNormWeights(m_LayerNormParameters.m_InputLayerNormWeights);
     ManagedConstTensorHandle managedForgetLayerNormWeights(m_LayerNormParameters.m_ForgetLayerNormWeights);
     ManagedConstTensorHandle managedCellLayerNormWeights(m_LayerNormParameters.m_CellLayerNormWeights);
     ManagedConstTensorHandle managedOutputLayerNormWeights(m_LayerNormParameters.m_OutputLayerNormWeights);

     // First add mandatory/basic parameters
     if (m_BasicParameters.m_InputToForgetWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedInputToForgetWeights.GetTensorInfo(),
                                               managedInputToForgetWeights.Map()));
     }
     if (m_BasicParameters.m_InputToCellWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedInputToCellWeights.GetTensorInfo(),
                                               managedInputToCellWeights.Map()));
     }
     if (m_BasicParameters.m_InputToOutputWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedInputToOutputWeights.GetTensorInfo(),
                                               managedInputToOutputWeights.Map()));
     }
     if (m_BasicParameters.m_RecurrentToForgetWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(
                 managedRecurrentToForgetWeights.GetTensorInfo(),
                 managedRecurrentToForgetWeights.Map()));
     }
     if (m_BasicParameters.m_RecurrentToCellWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(
                 managedRecurrentToCellWeights.GetTensorInfo(),
                 managedRecurrentToCellWeights.Map()));
     }
     if (m_BasicParameters.m_RecurrentToOutputWeights != nullptr)
     {
         constTensors.emplace_back(ConstTensor(
                 managedRecurrentToOutputWeights.GetTensorInfo(),
                 managedRecurrentToOutputWeights.Map()));
     }
     if (m_BasicParameters.m_ForgetGateBias != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedForgetGateBias.GetTensorInfo(),
                                               managedForgetGateBias.Map()));
     }
     if (m_BasicParameters.m_CellBias != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedCellBias.GetTensorInfo(),
                                               managedCellBias.Map()));
     }
     if (m_BasicParameters.m_OutputGateBias != nullptr)
     {
         constTensors.emplace_back(ConstTensor(managedOutputGateBias.GetTensorInfo(),
                                               managedOutputGateBias.Map()));
     }

     // Add cifg parameters
     if (!descriptor.m_CifgEnabled)
     {
         if (m_CifgParameters.m_InputToInputWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedInputToInputWeights.GetTensorInfo(),
                                                   managedInputToInputWeights.Map()));
         }
         if (m_CifgParameters.m_RecurrentToInputWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(
                     managedRecurrentToInputWeights.GetTensorInfo(),
                     managedRecurrentToInputWeights.Map()));
         }
         if (m_CifgParameters.m_InputGateBias != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedInputGateBias.GetTensorInfo(),
                                                   managedInputGateBias.Map()));
         }
     }

     // Add peephole parameters
     if (descriptor.m_PeepholeEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             if (m_PeepholeParameters.m_CellToInputWeights != nullptr)
             {
                 constTensors.emplace_back(ConstTensor(managedCellToInputWeights.GetTensorInfo(),
                                                       managedCellToInputWeights.Map()));
             }
         }
         if (m_PeepholeParameters.m_CellToForgetWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedCellToForgetWeights.GetTensorInfo(),
                                                   managedCellToForgetWeights.Map()));
         }
         if (m_PeepholeParameters.m_CellToOutputWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedCellToOutputWeights.GetTensorInfo(),
                                                   managedCellToOutputWeights.Map()));
         }
     }

     // Add projection parameters
     if (descriptor.m_ProjectionEnabled)
     {
         if (m_ProjectionParameters.m_ProjectionWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedProjectionWeights.GetTensorInfo(),
                                                   managedProjectionWeights.Map()));
         }
         if (m_ProjectionParameters.m_ProjectionBias != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedProjectionBias.GetTensorInfo(),
                                                   managedProjectionBias.Map()));
         }
     }

     // Add norm parameters
     if (descriptor.m_LayerNormEnabled)
     {
         if (!descriptor.m_CifgEnabled)
         {
             if (m_LayerNormParameters.m_InputLayerNormWeights != nullptr)
             {
                 constTensors.emplace_back(ConstTensor(managedInputLayerNormWeights.GetTensorInfo(),
                                                       managedInputLayerNormWeights.Map()));
             }
         }
         if (m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedForgetLayerNormWeights.GetTensorInfo(),
                                                   managedForgetLayerNormWeights.Map()));
         }
         if (m_LayerNormParameters.m_CellLayerNormWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedCellLayerNormWeights.GetTensorInfo(),
                                                   managedCellLayerNormWeights.Map()));
         }
         if (m_LayerNormParameters.m_OutputLayerNormWeights != nullptr)
         {
             constTensors.emplace_back(ConstTensor(managedOutputLayerNormWeights.GetTensorInfo(),
                                                   managedOutputLayerNormWeights.Map()));
         }
     }

     strategy.ExecuteStrategy(this, GetParameters(), constTensors, GetName());
 }

 } // namespace armnn
armnn::LstmBasicParameters::m_ForgetGateBias
std::shared_ptr< ConstTensorHandle > m_ForgetGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:69

+armnn::LstmBasicParameters::m_OutputGateBias
std::shared_ptr< ConstTensorHandle > m_OutputGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:73

+armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:959

+armnn::LstmOptLayerNormParameters::m_OutputLayerNormWeights
std::shared_ptr< ConstTensorHandle > m_OutputLayerNormWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:23

+armnn::UnidirectionalSequenceLstmLayer::m_PeepholeParameters
LstmOptPeepholeParameters m_PeepholeParameters
Definition: UnidirectionalSequenceLstmLayer.hpp:23

+armnn::LstmOptPeepholeParameters::m_CellToForgetWeights
std::shared_ptr< ConstTensorHandle > m_CellToForgetWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:49

+armnn::LayerWithParameters< LstmDescriptor >::m_Param
LstmDescriptor m_Param
The parameters for the layer (not including tensor-valued weights etc.).
Definition: LayerWithParameters.hpp:50

+armnn::UnidirectionalSequenceLstmLayer::UnidirectionalSequenceLstmLayer
UnidirectionalSequenceLstmLayer(const LstmDescriptor &param, const char *name)
Constructor to create a UnidirectionalSequenceLstmLayer.
Definition: UnidirectionalSequenceLstmLayer.cpp:17

+armnn::LayerWithParameters< LstmDescriptor >::GetParameters
const LstmDescriptor & GetParameters() const
Definition: LayerWithParameters.hpp:18

+armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:191

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputGateBias
const ConstTensorHandle * m_InputGateBias
Definition: WorkloadData.hpp:736

+TensorHandle.hpp

+WorkloadFactory.hpp

+armnn::IWorkloadFactory
Definition: WorkloadFactory.hpp:22

+armnn::UnidirectionalSequenceLstmLayer::m_ProjectionParameters
LstmOptProjectionParameters m_ProjectionParameters
Definition: UnidirectionalSequenceLstmLayer.hpp:22

+armnn::UnidirectionalSequenceLstmLayer::InferOutputShapes
std::vector< TensorShape > InferOutputShapes(const std::vector< TensorShape > &inputShapes) const override
By default returns inputShapes if the number of inputs are equal to number of outputs, otherwise infers the output shapes from given input shapes and layer properties.
Definition: UnidirectionalSequenceLstmLayer.cpp:150

+armnn::IStrategy::ExecuteStrategy
virtual void ExecuteStrategy(const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0)=0

+armnn::UnidirectionalSequenceLstmLayer::ValidateTensorShapesFromInputs
void ValidateTensorShapesFromInputs() override
Check if the input tensor shape(s) will lead to a valid configuration of UnidirectionalSequenceLstmLa...
Definition: UnidirectionalSequenceLstmLayer.cpp:170

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToCellWeights
const ConstTensorHandle * m_RecurrentToCellWeights
Definition: WorkloadData.hpp:731

+armnn::LstmOptLayerNormParameters::m_InputLayerNormWeights
std::shared_ptr< ConstTensorHandle > m_InputLayerNormWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:17

+armnn::UnidirectionalSequenceLstmLayer::CreateWorkload
virtual std::unique_ptr< IWorkload > CreateWorkload(const IWorkloadFactory &factory) const override
Makes a workload for the UnidirectionalSequence LSTM type.
Definition: UnidirectionalSequenceLstmLayer.cpp:22

+armnn::UnidirectionalSequenceLstmLayer::m_LayerNormParameters
LstmOptLayerNormParameters m_LayerNormParameters
Definition: UnidirectionalSequenceLstmLayer.hpp:24

+armnn::LstmOptProjectionParameters::m_ProjectionWeights
std::shared_ptr< ConstTensorHandle > m_ProjectionWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
Definition: LstmParameters.hpp:39

+armnn::UnidirectionalSequenceLstmLayer::Accept
void Accept(ILayerVisitor &visitor) const override
Apply a visitor to this layer.
Definition: UnidirectionalSequenceLstmLayer.cpp:310

+armnn::Layer::VerifyShapeInferenceType
void VerifyShapeInferenceType(const TensorShape &outputShape, ShapeInferenceMethod shapeInferenceMethod)
Definition: Layer.cpp:433

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToInputWeights
const ConstTensorHandle * m_InputToInputWeights
Definition: WorkloadData.hpp:725

+armnn::UnidirectionalSequenceLstmLayer::ExecuteStrategy
void ExecuteStrategy(IStrategy &strategy) const override
Apply a visitor to this layer.
Definition: UnidirectionalSequenceLstmLayer.cpp:316

+armnn::LstmDescriptor::m_TimeMajor
bool m_TimeMajor
Enable/disable time major.
Definition: Descriptors.hpp:963

+armnn::ManagedConstTensorHandle::GetTensorInfo
const TensorInfo & GetTensorInfo() const
Definition: TensorHandle.hpp:230

+armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6

+armnn::LstmBasicParameters::m_InputToCellWeights
std::shared_ptr< ConstTensorHandle > m_InputToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
Definition: LstmParameters.hpp:59

+armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14

+LstmParams.hpp

+UnidirectionalSequenceLstmLayer.hpp

+armnn::TensorShape
Definition: Tensor.hpp:20

+armnn::InputSlot::GetConnection
const IOutputSlot * GetConnection() const override
Definition: Layer.hpp:199

+armnn::Layer::ValidateAndCopyShape
void ValidateAndCopyShape(const TensorShape &outputShape, const TensorShape &inferredShape, const ShapeInferenceMethod shapeInferenceMethod, const std::string &layerName, const unsigned int outputSlotIndex=0)
Definition: Layer.cpp:393

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_OutputGateBias
const ConstTensorHandle * m_OutputGateBias
Definition: WorkloadData.hpp:739

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionBias
const ConstTensorHandle * m_ProjectionBias
Definition: WorkloadData.hpp:741

+armnn::IWorkloadFactory::CreateUnidirectionalSequenceLstm
virtual std::unique_ptr< IWorkload > CreateUnidirectionalSequenceLstm(const UnidirectionalSequenceLstmQueueDescriptor &descriptor, const WorkloadInfo &info) const
Definition: WorkloadFactory.cpp:1889

+armnn::LstmOptCifgParameters::m_InputGateBias
std::shared_ptr< ConstTensorHandle > m_InputGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:33

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToOutputWeights
const ConstTensorHandle * m_InputToOutputWeights
Definition: WorkloadData.hpp:728

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToCellWeights
const ConstTensorHandle * m_InputToCellWeights
Definition: WorkloadData.hpp:727

+armnn::LstmOptPeepholeParameters::m_CellToOutputWeights
std::shared_ptr< ConstTensorHandle > m_CellToOutputWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:51

+armnn::IStrategy
Definition: IStrategy.hpp:13

+armnn::Layer::VerifyLayerConnections
void VerifyLayerConnections(unsigned int expectedConnections, const CheckLocation &location) const
Definition: Layer.cpp:349

+armnn::Layer::GetInputSlot
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
Definition: Layer.hpp:316

+TypesUtils.hpp

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputToForgetWeights
const ConstTensorHandle * m_InputToForgetWeights
Definition: WorkloadData.hpp:726

+armnn::LstmBasicParameters::m_RecurrentToCellWeights
std::shared_ptr< ConstTensorHandle > m_RecurrentToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
Definition: LstmParameters.hpp:65

+armnn::LstmBasicParameters::m_CellBias
std::shared_ptr< ConstTensorHandle > m_CellBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:71

+armnn::Layer::ConstantTensors
std::vector< std::reference_wrapper< std::shared_ptr< ConstTensorHandle > >> ConstantTensors
Definition: Layer.hpp:393

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellLayerNormWeights
const ConstTensorHandle * m_CellLayerNormWeights
Definition: WorkloadData.hpp:744

+armnn::UnidirectionalSequenceLstmLayer::m_CifgParameters
LstmOptCifgParameters m_CifgParameters
Definition: UnidirectionalSequenceLstmLayer.hpp:21

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToInputWeights
const ConstTensorHandle * m_CellToInputWeights
Definition: WorkloadData.hpp:733

+armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:923

+ARMNN_ASSERT_MSG
#define ARMNN_ASSERT_MSG(COND, MSG)
Definition: Assert.hpp:15

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ProjectionWeights
const ConstTensorHandle * m_ProjectionWeights
Definition: WorkloadData.hpp:740

+armnn::UnidirectionalSequenceLstmLayer::m_BasicParameters
LstmBasicParameters m_BasicParameters
Definition: UnidirectionalSequenceLstmLayer.hpp:20

+armnn::UnidirectionalSequenceLstmLayer::Clone
UnidirectionalSequenceLstmLayer * Clone(Graph &graph) const override
Creates a dynamically-allocated copy of this layer.
Definition: UnidirectionalSequenceLstmLayer.cpp:80

+armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:327

+armnn::LstmOptCifgParameters::m_RecurrentToInputWeights
std::shared_ptr< ConstTensorHandle > m_RecurrentToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
Definition: LstmParameters.hpp:31

+armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:957

+armnn::LstmOptLayerNormParameters::m_CellLayerNormWeights
std::shared_ptr< ConstTensorHandle > m_CellLayerNormWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:21

+ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14

+armnn::LstmBasicParameters::m_RecurrentToOutputWeights
std::shared_ptr< ConstTensorHandle > m_RecurrentToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
Definition: LstmParameters.hpp:67

+armnn::LstmOptCifgParameters::m_InputToInputWeights
std::shared_ptr< ConstTensorHandle > m_InputToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
Definition: LstmParameters.hpp:29

+CHECK_LOCATION
#define CHECK_LOCATION()
Definition: Exceptions.hpp:197

+armnn::LstmOptProjectionParameters::m_ProjectionBias
std::shared_ptr< ConstTensorHandle > m_ProjectionBias
A unique pointer to represent 1D weights tensor with dimensions [output_size].
Definition: LstmParameters.hpp:41

+armnn::Graph
Definition: Graph.hpp:29

+armnn::Layer::SetAdditionalInfo
void SetAdditionalInfo(QueueDescriptor &descriptor) const
Definition: Layer.cpp:245

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ForgetLayerNormWeights
const ConstTensorHandle * m_ForgetLayerNormWeights
Definition: WorkloadData.hpp:743

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_OutputLayerNormWeights
const ConstTensorHandle * m_OutputLayerNormWeights
Definition: WorkloadData.hpp:745

+armnn::LstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
Definition: Descriptors.hpp:955

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_ForgetGateBias
const ConstTensorHandle * m_ForgetGateBias
Definition: WorkloadData.hpp:737

+armnn::UnidirectionalSequenceLstmLayer
This layer represents a LSTM operation.
Definition: UnidirectionalSequenceLstmLayer.hpp:16

+armnn::LstmBasicParameters::m_InputToForgetWeights
std::shared_ptr< ConstTensorHandle > m_InputToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
Definition: LstmParameters.hpp:57

+armnn::LstmBasicParameters::m_RecurrentToForgetWeights
std::shared_ptr< ConstTensorHandle > m_RecurrentToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
Definition: LstmParameters.hpp:63

+armnn::UnidirectionalSequenceLstmLayer::GetConstantTensorsByRef
Layer::ConstantTensors GetConstantTensorsByRef() override
Retrieve the handles to the constant values stored by the layer.
Definition: UnidirectionalSequenceLstmLayer.cpp:277

+armnn::Exception
Base class for all ArmNN exceptions so that users can filter to just those.
Definition: Exceptions.hpp:46

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellBias
const ConstTensorHandle * m_CellBias
Definition: WorkloadData.hpp:738

+armnn::ManagedConstTensorHandle
Definition: TensorHandle.hpp:178

+armnn::LayerWithParameters< LstmDescriptor >::PrepInfoAndDesc
WorkloadInfo PrepInfoAndDesc(QueueDescriptor &descriptor) const
Helper function to reduce duplication in *LayerCreateWorkload.
Definition: LayerWithParameters.hpp:43

+armnn::ILayerVisitor
Definition: ILayerVisitor.hpp:16

+armnn::LstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:961

+armnn::Layer::GetOutputSlot
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
Get the const output slot handle by slot index.
Definition: Layer.hpp:318

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToInputWeights
const ConstTensorHandle * m_RecurrentToInputWeights
Definition: WorkloadData.hpp:729

+armnn::IOutputSlot::GetTensorInfo
virtual const TensorInfo & GetTensorInfo() const =0

+armnn::Layer::GetName
const char * GetName() const override
Returns the name of the layer.
Definition: Layer.hpp:311

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToForgetWeights
const ConstTensorHandle * m_CellToForgetWeights
Definition: WorkloadData.hpp:734

+armnn::UnidirectionalSequenceLstmQueueDescriptor
Definition: WorkloadData.hpp:698

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToOutputWeights
const ConstTensorHandle * m_RecurrentToOutputWeights
Definition: WorkloadData.hpp:732

+armnn::LayerWithParameters
Definition: LayerWithParameters.hpp:13

+armnn::LstmOptLayerNormParameters::m_ForgetLayerNormWeights
std::shared_ptr< ConstTensorHandle > m_ForgetLayerNormWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:19

+armnn::LstmOptPeepholeParameters::m_CellToInputWeights
std::shared_ptr< ConstTensorHandle > m_CellToInputWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Definition: LstmParameters.hpp:47

+armnn::ManagedConstTensorHandle::Map
const void * Map(bool blocking=true)
RAII Managed resource Unmaps MemoryArea once out of scope.
Definition: TensorHandle.hpp:187

+armnn::OutputSlot::GetTensorInfo
const TensorInfo & GetTensorInfo() const override
Definition: Layer.cpp:63

+armnn::LayerType::UnidirectionalSequenceLstm

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_RecurrentToForgetWeights
const ConstTensorHandle * m_RecurrentToForgetWeights
Definition: WorkloadData.hpp:730

+armnn::Layer::m_ShapeInferenceMethod
ShapeInferenceMethod m_ShapeInferenceMethod
Definition: Layer.hpp:408

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_CellToOutputWeights
const ConstTensorHandle * m_CellToOutputWeights
Definition: WorkloadData.hpp:735

+LayerCloneBase.hpp

+armnn::UnidirectionalSequenceLstmQueueDescriptor::m_InputLayerNormWeights
const ConstTensorHandle * m_InputLayerNormWeights
Definition: WorkloadData.hpp:742

+armnn::LstmBasicParameters::m_InputToOutputWeights
std::shared_ptr< ConstTensorHandle > m_InputToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
Definition: LstmParameters.hpp:61

+armnn::LayerType
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...
Definition: Types.hpp:405

+