patch/20.02/_quantized_lstm_layer_8cpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #include "QuantizedLstmLayer.hpp"

 #include "LayerCloneBase.hpp"

 #include <armnn/QuantizedLstmParams.hpp>
 #include <armnn/TypesUtils.hpp>
 #include <backendsCommon/CpuTensorHandle.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>

 namespace armnn
 {

 QuantizedLstmLayer::QuantizedLstmLayer(const char* name)
     : Layer(3, 2, LayerType::QuantizedLstm, name)
 {
 }

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

     // QuantizedLstmLayer parameters - there are no optional params
     descriptor.m_InputToInputWeights  = m_QuantizedLstmParameters.m_InputToInputWeights.get();
     descriptor.m_InputToForgetWeights = m_QuantizedLstmParameters.m_InputToForgetWeights.get();
     descriptor.m_InputToCellWeights   = m_QuantizedLstmParameters.m_InputToCellWeights.get();
     descriptor.m_InputToOutputWeights = m_QuantizedLstmParameters.m_InputToOutputWeights.get();

     descriptor.m_RecurrentToInputWeights  = m_QuantizedLstmParameters.m_RecurrentToInputWeights.get();
     descriptor.m_RecurrentToForgetWeights = m_QuantizedLstmParameters.m_RecurrentToForgetWeights.get();
     descriptor.m_RecurrentToCellWeights   = m_QuantizedLstmParameters.m_RecurrentToCellWeights.get();
     descriptor.m_RecurrentToOutputWeights = m_QuantizedLstmParameters.m_RecurrentToOutputWeights.get();

     descriptor.m_InputGateBias  = m_QuantizedLstmParameters.m_InputGateBias.get();
     descriptor.m_ForgetGateBias = m_QuantizedLstmParameters.m_ForgetGateBias.get();
     descriptor.m_CellBias       = m_QuantizedLstmParameters.m_CellBias.get();
     descriptor.m_OutputGateBias = m_QuantizedLstmParameters.m_OutputGateBias.get();

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

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

     layer->m_QuantizedLstmParameters.m_InputToInputWeights = m_QuantizedLstmParameters.m_InputToInputWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_InputToInputWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_InputToForgetWeights = m_QuantizedLstmParameters.m_InputToForgetWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_InputToForgetWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_InputToCellWeights = m_QuantizedLstmParameters.m_InputToCellWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_InputToCellWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_InputToOutputWeights = m_QuantizedLstmParameters.m_InputToOutputWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_InputToOutputWeights) : nullptr;

     layer->m_QuantizedLstmParameters.m_RecurrentToInputWeights = m_QuantizedLstmParameters.m_RecurrentToInputWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_RecurrentToInputWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights = m_QuantizedLstmParameters.m_RecurrentToForgetWeights
             ? std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_RecurrentToForgetWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_RecurrentToCellWeights = m_QuantizedLstmParameters.m_RecurrentToCellWeights ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_RecurrentToCellWeights) : nullptr;
     layer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights = m_QuantizedLstmParameters.m_RecurrentToOutputWeights
             ? std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_RecurrentToOutputWeights) : nullptr;

     layer->m_QuantizedLstmParameters.m_InputGateBias = m_QuantizedLstmParameters.m_InputGateBias ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_InputGateBias) : nullptr;
     layer->m_QuantizedLstmParameters.m_ForgetGateBias = m_QuantizedLstmParameters.m_ForgetGateBias ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_ForgetGateBias) : nullptr;
     layer->m_QuantizedLstmParameters.m_CellBias = m_QuantizedLstmParameters.m_CellBias ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_CellBias) : nullptr;
     layer->m_QuantizedLstmParameters.m_OutputGateBias = m_QuantizedLstmParameters.m_OutputGateBias ?
             std::make_unique<ScopedCpuTensorHandle>(*m_QuantizedLstmParameters.m_OutputGateBias) : nullptr;

     return std::move(layer);
 }

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

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

     std::vector<TensorShape> outShapes;
     outShapes.push_back(TensorShape({numBatches, outputSize})); // cellStateOut
     outShapes.push_back(TensorShape({numBatches, outputSize})); // output

     return outShapes;
 }

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

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

     BOOST_ASSERT(inferredShapes.size() == 2);

     // Check weights and bias for nullptr
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_InputToInputWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_InputToInputWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_InputToForgetWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_InputToForgetWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_InputToCellWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_InputToCellWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_InputToOutputWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_InputToOutputWeights should not be null.");

     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_RecurrentToInputWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_RecurrentToInputWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_RecurrentToForgetWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_RecurrentToForgetWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_RecurrentToCellWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_RecurrentToCellWeights should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_RecurrentToOutputWeights != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_RecurrentToOutputWeights should not be null.");

     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_InputGateBias != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_InputGateBias should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_ForgetGateBias != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_ForgetGateBias should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_CellBias != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_CellBias should not be null.");
     BOOST_ASSERT_MSG(m_QuantizedLstmParameters.m_OutputGateBias != nullptr,
                      "QuantizedLstmLayer: m_QuantizedLstmParameters.m_OutputGateBias should not be null.");

     // Check output TensorShape(s) match inferred shape
     ConditionalThrowIfNotEqual<LayerValidationException>(
             "QuantizedLstmLayer: TensorShape set on OutputSlot[0] does not match the inferred shape.",
             GetOutputSlot(0).GetTensorInfo().GetShape(),
             inferredShapes[0]);

     ConditionalThrowIfNotEqual<LayerValidationException>(
             "QuantizedLstmLayer: TensorShape set on OutputSlot[1] does not match the inferred shape.",
             GetOutputSlot(1).GetTensorInfo().GetShape(),
             inferredShapes[1]);
 }

 Layer::ConstantTensors QuantizedLstmLayer::GetConstantTensorsByRef()
 {
     return
     {
         m_QuantizedLstmParameters.m_InputToInputWeights,
         m_QuantizedLstmParameters.m_InputToForgetWeights,
         m_QuantizedLstmParameters.m_InputToCellWeights,
         m_QuantizedLstmParameters.m_InputToOutputWeights,

         m_QuantizedLstmParameters.m_RecurrentToInputWeights,
         m_QuantizedLstmParameters.m_RecurrentToForgetWeights,
         m_QuantizedLstmParameters.m_RecurrentToCellWeights,
         m_QuantizedLstmParameters.m_RecurrentToOutputWeights,

         m_QuantizedLstmParameters.m_InputGateBias,
         m_QuantizedLstmParameters.m_ForgetGateBias,
         m_QuantizedLstmParameters.m_CellBias,
         m_QuantizedLstmParameters.m_OutputGateBias
     };
 }

 void QuantizedLstmLayer::Accept(ILayerVisitor& visitor) const
 {
     QuantizedLstmInputParams inputParams;

     // InputToX weight tensors
     ConstTensor inputToInputWeightsTensor;
     if (m_QuantizedLstmParameters.m_InputToInputWeights != nullptr)
     {
         ConstTensor inputToInputWeightsTensorCopy(m_QuantizedLstmParameters.m_InputToInputWeights->GetTensorInfo(),
                                                   m_QuantizedLstmParameters.m_InputToInputWeights->Map(true));
         inputToInputWeightsTensor = inputToInputWeightsTensorCopy;
         inputParams.m_InputToInputWeights = &inputToInputWeightsTensor;
     }

     ConstTensor inputToForgetWeightsTensor;
     if (m_QuantizedLstmParameters.m_InputToForgetWeights != nullptr)
     {
         ConstTensor inputToForgetWeightsTensorCopy(m_QuantizedLstmParameters.m_InputToForgetWeights->GetTensorInfo(),
                                                    m_QuantizedLstmParameters.m_InputToForgetWeights->Map(true));
         inputToForgetWeightsTensor = inputToForgetWeightsTensorCopy;
         inputParams.m_InputToForgetWeights = &inputToForgetWeightsTensor;
     }

     ConstTensor inputToCellWeightsTensor;
     if (m_QuantizedLstmParameters.m_InputToCellWeights != nullptr)
     {
         ConstTensor inputToCellWeightsTensorCopy(m_QuantizedLstmParameters.m_InputToCellWeights->GetTensorInfo(),
                                                  m_QuantizedLstmParameters.m_InputToCellWeights->Map(true));
         inputToCellWeightsTensor = inputToCellWeightsTensorCopy;
         inputParams.m_InputToCellWeights = &inputToCellWeightsTensor;
     }

     ConstTensor inputToOutputWeightsTensor;
     if (m_QuantizedLstmParameters.m_InputToOutputWeights != nullptr)
     {
         ConstTensor inputToOutputWeightsTensorCopy(m_QuantizedLstmParameters.m_InputToOutputWeights->GetTensorInfo(),
                                                    m_QuantizedLstmParameters.m_InputToOutputWeights->Map(true));
         inputToOutputWeightsTensor = inputToOutputWeightsTensorCopy;
         inputParams.m_InputToOutputWeights = &inputToOutputWeightsTensor;
     }

     // RecurrentToX weight tensors
     ConstTensor recurrentToInputWeightsTensor;
     if (m_QuantizedLstmParameters.m_RecurrentToInputWeights != nullptr)
     {
         ConstTensor recurrentToInputWeightsTensorCopy(
                 m_QuantizedLstmParameters.m_RecurrentToInputWeights->GetTensorInfo(),
                 m_QuantizedLstmParameters.m_RecurrentToInputWeights->Map(true));
         recurrentToInputWeightsTensor = recurrentToInputWeightsTensorCopy;
         inputParams.m_RecurrentToInputWeights = &recurrentToInputWeightsTensor;
     }

     ConstTensor recurrentToForgetWeightsTensor;
     if (m_QuantizedLstmParameters.m_RecurrentToForgetWeights != nullptr)
     {
         ConstTensor recurrentToForgetWeightsTensorCopy(
                 m_QuantizedLstmParameters.m_RecurrentToForgetWeights->GetTensorInfo(),
                 m_QuantizedLstmParameters.m_RecurrentToForgetWeights->Map(true));
         recurrentToForgetWeightsTensor = recurrentToForgetWeightsTensorCopy;
         inputParams.m_RecurrentToForgetWeights = &recurrentToForgetWeightsTensor;
     }

     ConstTensor recurrentToCellWeightsTensor;
     if (m_QuantizedLstmParameters.m_RecurrentToCellWeights != nullptr)
     {
         ConstTensor recurrentToCellWeightsTensorCopy(
                 m_QuantizedLstmParameters.m_RecurrentToCellWeights->GetTensorInfo(),
                 m_QuantizedLstmParameters.m_RecurrentToCellWeights->Map(true));
         recurrentToCellWeightsTensor = recurrentToCellWeightsTensorCopy;
         inputParams.m_RecurrentToCellWeights = &recurrentToCellWeightsTensor;
     }

     ConstTensor recurrentToOutputWeightsTensor;
     if (m_QuantizedLstmParameters.m_RecurrentToOutputWeights != nullptr)
     {
         ConstTensor recurrentToOutputWeightsTensorCopy(
                 m_QuantizedLstmParameters.m_RecurrentToOutputWeights->GetTensorInfo(),
                 m_QuantizedLstmParameters.m_RecurrentToOutputWeights->Map(true));
         recurrentToOutputWeightsTensor = recurrentToOutputWeightsTensorCopy;
         inputParams.m_RecurrentToOutputWeights = &recurrentToOutputWeightsTensor;
     }

     // Bias tensors
     ConstTensor inputGateBiasTensor;
     if (m_QuantizedLstmParameters.m_InputGateBias != nullptr)
     {
         ConstTensor inputGateBiasTensorCopy(m_QuantizedLstmParameters.m_InputGateBias->GetTensorInfo(),
                                             m_QuantizedLstmParameters.m_InputGateBias->Map(true));
         inputGateBiasTensor = inputGateBiasTensorCopy;
         inputParams.m_InputGateBias = &inputGateBiasTensor;
     }

     ConstTensor forgetGateBiasTensor;
     if (m_QuantizedLstmParameters.m_ForgetGateBias != nullptr)
     {
         ConstTensor forgetGateBiasTensorCopy(m_QuantizedLstmParameters.m_ForgetGateBias->GetTensorInfo(),
                                              m_QuantizedLstmParameters.m_ForgetGateBias->Map(true));
         forgetGateBiasTensor = forgetGateBiasTensorCopy;
         inputParams.m_ForgetGateBias = &forgetGateBiasTensor;
     }

     ConstTensor cellBiasTensor;
     if (m_QuantizedLstmParameters.m_CellBias != nullptr)
     {
         ConstTensor cellBiasTensorCopy(m_QuantizedLstmParameters.m_CellBias->GetTensorInfo(),
                                        m_QuantizedLstmParameters.m_CellBias->Map(true));
         cellBiasTensor = cellBiasTensorCopy;
         inputParams.m_CellBias = &cellBiasTensor;
     }

     ConstTensor outputGateBiasTensor;
     if (m_QuantizedLstmParameters.m_OutputGateBias != nullptr)
     {
         ConstTensor outputGateBiasCopy(m_QuantizedLstmParameters.m_OutputGateBias->GetTensorInfo(),
                                        m_QuantizedLstmParameters.m_OutputGateBias->Map(true));
         outputGateBiasTensor = outputGateBiasCopy;
         inputParams.m_OutputGateBias = &outputGateBiasTensor;
     }

     visitor.VisitQuantizedLstmLayer(this, inputParams, GetName());
 }

 } // namespace armnn
armnn::QuantizedLstmQueueDescriptor::m_RecurrentToForgetWeights
const ConstCpuTensorHandle * m_RecurrentToForgetWeights
Definition: WorkloadData.hpp:537

+armnn::QuantizedLstmParameters::m_RecurrentToInputWeights
std::unique_ptr< ScopedCpuTensorHandle > m_RecurrentToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:26

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

+armnn::QuantizedLstmQueueDescriptor::m_InputGateBias
const ConstCpuTensorHandle * m_InputGateBias
Definition: WorkloadData.hpp:541

+armnn::QuantizedLstmInputParams::m_InputToCellWeights
const ConstTensor * m_InputToCellWeights
Definition: QuantizedLstmParams.hpp:35

+armnn::QuantizedLstmLayer::m_QuantizedLstmParameters
QuantizedLstmParameters m_QuantizedLstmParameters
Definition: QuantizedLstmLayer.hpp:49

+armnn::QuantizedLstmInputParams::m_CellBias
const ConstTensor * m_CellBias
Definition: QuantizedLstmParams.hpp:45

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

+armnn::QuantizedLstmParameters::m_InputToForgetWeights
std::unique_ptr< ScopedCpuTensorHandle > m_InputToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:19

+armnn::QuantizedLstmInputParams::m_RecurrentToOutputWeights
const ConstTensor * m_RecurrentToOutputWeights
Definition: QuantizedLstmParams.hpp:41

+armnn::QuantizedLstmParameters::m_RecurrentToOutputWeights
std::unique_ptr< ScopedCpuTensorHandle > m_RecurrentToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:32

+armnn::QuantizedLstmQueueDescriptor
Definition: WorkloadData.hpp:512

+WorkloadFactory.hpp

+armnn::QuantizedLstmInputParams::m_RecurrentToForgetWeights
const ConstTensor * m_RecurrentToForgetWeights
Definition: QuantizedLstmParams.hpp:39

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

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

+armnn::QuantizedLstmQueueDescriptor::m_InputToCellWeights
const ConstCpuTensorHandle * m_InputToCellWeights
Definition: WorkloadData.hpp:533

+armnn::QuantizedLstmInputParams::m_ForgetGateBias
const ConstTensor * m_ForgetGateBias
Definition: QuantizedLstmParams.hpp:44

+QuantizedLstmParams.hpp

+armnn::IWorkloadFactory::CreateQuantizedLstm
virtual std::unique_ptr< IWorkload > CreateQuantizedLstm(const QuantizedLstmQueueDescriptor &descriptor, const WorkloadInfo &info) const
Definition: WorkloadFactory.cpp:1364

+armnn::QuantizedLstmInputParams::m_InputGateBias
const ConstTensor * m_InputGateBias
Definition: QuantizedLstmParams.hpp:43

+armnn::QuantizedLstmParameters::m_InputToInputWeights
std::unique_ptr< ScopedCpuTensorHandle > m_InputToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:17

+armnn::QuantizedLstmParameters::m_RecurrentToForgetWeights
std::unique_ptr< ScopedCpuTensorHandle > m_RecurrentToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:28

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

+armnn
Copyright (c) 2020 ARM Limited.
Definition: 00_introduction.dox:25

+armnn::QuantizedLstmInputParams
Definition: QuantizedLstmParams.hpp:13

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

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

+armnn::QuantizedLstmLayer::QuantizedLstmLayer
QuantizedLstmLayer(const char *name)
Constructor to create a QuantizedLstmLayer.
Definition: QuantizedLstmLayer.cpp:17

+armnn::QuantizedLstmParameters::m_InputGateBias
std::unique_ptr< ScopedCpuTensorHandle > m_InputGateBias
A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32).
Definition: QuantizedLstmLayer.hpp:35

+armnn::QuantizedLstmParameters::m_CellBias
std::unique_ptr< ScopedCpuTensorHandle > m_CellBias
A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32).
Definition: QuantizedLstmLayer.hpp:39

+armnn::QuantizedLstmInputParams::m_InputToInputWeights
const ConstTensor * m_InputToInputWeights
Definition: QuantizedLstmParams.hpp:33

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

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

+TypesUtils.hpp

+armnn::QuantizedLstmLayer
This layer represents a QuantizedLstm operation.
Definition: QuantizedLstmLayer.hpp:45

+armnn::Layer::PrepInfoAndDesc
WorkloadInfo PrepInfoAndDesc(QueueDescriptor &descriptor) const
Helper function to reduce duplication in *LayerCreateWorkload.
Definition: Layer.hpp:351

+armnn::QuantizedLstmParameters::m_ForgetGateBias
std::unique_ptr< ScopedCpuTensorHandle > m_ForgetGateBias
A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32).
Definition: QuantizedLstmLayer.hpp:37

+armnn::QuantizedLstmInputParams::m_InputToForgetWeights
const ConstTensor * m_InputToForgetWeights
Definition: QuantizedLstmParams.hpp:34

+armnn::QuantizedLstmQueueDescriptor::m_ForgetGateBias
const ConstCpuTensorHandle * m_ForgetGateBias
Definition: WorkloadData.hpp:542

+QuantizedLstmLayer.hpp

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

+armnn::QuantizedLstmInputParams::m_OutputGateBias
const ConstTensor * m_OutputGateBias
Definition: QuantizedLstmParams.hpp:46

+armnn::QuantizedLstmQueueDescriptor::m_RecurrentToInputWeights
const ConstCpuTensorHandle * m_RecurrentToInputWeights
Definition: WorkloadData.hpp:536

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

+armnn::QuantizedLstmQueueDescriptor::m_RecurrentToCellWeights
const ConstCpuTensorHandle * m_RecurrentToCellWeights
Definition: WorkloadData.hpp:538

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

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

+armnn::QuantizedLstmQueueDescriptor::m_RecurrentToOutputWeights
const ConstCpuTensorHandle * m_RecurrentToOutputWeights
Definition: WorkloadData.hpp:539

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

+armnn::QuantizedLstmInputParams::m_RecurrentToInputWeights
const ConstTensor * m_RecurrentToInputWeights
Definition: QuantizedLstmParams.hpp:38

+armnn::ILayerVisitor::VisitQuantizedLstmLayer
virtual void VisitQuantizedLstmLayer(const IConnectableLayer *layer, const QuantizedLstmInputParams &params, const char *name=nullptr)=0
Function a QuantizedLstm layer should call back to when its Accept(ILayerVisitor&) function is invoke...

+CpuTensorHandle.hpp

+armnn::QuantizedLstmParameters::m_OutputGateBias
std::unique_ptr< ScopedCpuTensorHandle > m_OutputGateBias
A unique pointer to represent 1D bias tensor with dimensions [outputSize] (int32).
Definition: QuantizedLstmLayer.hpp:41

+armnn::QuantizedLstmQueueDescriptor::m_CellBias
const ConstCpuTensorHandle * m_CellBias
Definition: WorkloadData.hpp:543

+armnn::LayerType::QuantizedLstm

+armnn::QuantizedLstmInputParams::m_RecurrentToCellWeights
const ConstTensor * m_RecurrentToCellWeights
Definition: QuantizedLstmParams.hpp:40

+armnn::QuantizedLstmQueueDescriptor::m_OutputGateBias
const ConstCpuTensorHandle * m_OutputGateBias
Definition: WorkloadData.hpp:544

+armnn::QuantizedLstmInputParams::m_InputToOutputWeights
const ConstTensor * m_InputToOutputWeights
Definition: QuantizedLstmParams.hpp:36

+armnn::QuantizedLstmParameters::m_InputToCellWeights
std::unique_ptr< ScopedCpuTensorHandle > m_InputToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:21

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

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

+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:305

+armnn::QuantizedLstmQueueDescriptor::m_InputToForgetWeights
const ConstCpuTensorHandle * m_InputToForgetWeights
Definition: WorkloadData.hpp:532

+armnn::QuantizedLstmParameters::m_InputToOutputWeights
std::unique_ptr< ScopedCpuTensorHandle > m_InputToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, inputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:23

+armnn::QuantizedLstmQueueDescriptor::m_InputToOutputWeights
const ConstCpuTensorHandle * m_InputToOutputWeights
Definition: WorkloadData.hpp:534

+armnn::Layer::ConstantTensors
std::vector< std::reference_wrapper< std::unique_ptr< ScopedCpuTensorHandle > >> ConstantTensors
Definition: Layer.hpp:363

+armnn::QuantizedLstmQueueDescriptor::m_InputToInputWeights
const ConstCpuTensorHandle * m_InputToInputWeights
Definition: WorkloadData.hpp:531

+armnn::QuantizedLstmParameters::m_RecurrentToCellWeights
std::unique_ptr< ScopedCpuTensorHandle > m_RecurrentToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [outputSize, outputSize] (QAsymm8)...
Definition: QuantizedLstmLayer.hpp:30

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

+armnn::QuantizedLstmLayer::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: QuantizedLstmLayer.cpp:79

+armnn::Layer
Definition: Layer.hpp:209

+LayerCloneBase.hpp

+armnn::LayerType
LayerType
Definition: InternalTypes.hpp:14

+