IVGCVSW-4549 Add front end for new QLSTM layer

* Added new layer QLstm (Android R HAL 1.3)
* Made necessary updates to APIs
* Added unit tests
* This layer is functionally equivalent to the
  original unquantized LSTM layer with some
  additonal quantization features added. Due
  to this, original LstmParams are used for
  this layer.

Signed-off-by: James Conroy <james.conroy@arm.com>
Change-Id: I5b7f2d2fb6e17e81573b41a31bc55f49ae79608f

2 files changed, 636 insertions, 0 deletions

diff --git a/src/armnn/layers/QLstmLayer.cpp b/src/armnn/layers/QLstmLayer.cpp
new file mode 100644
index 0000000000..393a7029aa
--- /dev/null
+++ b/src/armnn/layers/QLstmLayer.cpp
@@ -0,0 +1,512 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "QLstmLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/LstmParams.hpp>
+#include <armnn/TypesUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+namespace armnn
+{
+
+QLstmLayer::QLstmLayer(const QLstmDescriptor& param, const char* name)
+        : LayerWithParameters(3, 3, LayerType::QLstm, param, name)
+{
+}
+
+std::unique_ptr<IWorkload> QLstmLayer::CreateWorkload(const IWorkloadFactory& factory) const
+{
+    QLstmQueueDescriptor 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();
+    }
+
+    return factory.CreateQLstm(descriptor, PrepInfoAndDesc(descriptor));
+}
+
+QLstmLayer* QLstmLayer::Clone(Graph& graph) const
+{
+    auto layer = CloneBase<QLstmLayer>(graph, m_Param, GetName());
+
+    layer->m_BasicParameters.m_InputToForgetWeights = m_BasicParameters.m_InputToForgetWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_InputToForgetWeights) : nullptr;
+    layer->m_BasicParameters.m_InputToCellWeights = m_BasicParameters.m_InputToCellWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_InputToCellWeights) : nullptr;
+    layer->m_BasicParameters.m_InputToOutputWeights = m_BasicParameters.m_InputToOutputWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_InputToOutputWeights) : nullptr;
+    layer->m_BasicParameters.m_RecurrentToForgetWeights = m_BasicParameters.m_RecurrentToForgetWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_RecurrentToForgetWeights) : nullptr;
+    layer->m_BasicParameters.m_RecurrentToCellWeights = m_BasicParameters.m_RecurrentToCellWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_RecurrentToCellWeights) : nullptr;
+    layer->m_BasicParameters.m_RecurrentToOutputWeights = m_BasicParameters.m_RecurrentToOutputWeights ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_RecurrentToOutputWeights) : nullptr;
+    layer->m_BasicParameters.m_ForgetGateBias = m_BasicParameters.m_ForgetGateBias ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_ForgetGateBias) : nullptr;
+    layer->m_BasicParameters.m_CellBias = m_BasicParameters.m_CellBias ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_CellBias) : nullptr;
+    layer->m_BasicParameters.m_OutputGateBias = m_BasicParameters.m_OutputGateBias ?
+            std::make_unique<ScopedCpuTensorHandle>(*m_BasicParameters.m_OutputGateBias) : nullptr;
+
+    if (!m_Param.m_CifgEnabled)
+    {
+        layer->m_CifgParameters.m_InputToInputWeights = m_CifgParameters.m_InputToInputWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_CifgParameters.m_InputToInputWeights) : nullptr;
+        layer->m_CifgParameters.m_RecurrentToInputWeights = m_CifgParameters.m_RecurrentToInputWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_CifgParameters.m_RecurrentToInputWeights) : nullptr;
+        layer->m_CifgParameters.m_InputGateBias = m_CifgParameters.m_InputGateBias ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_CifgParameters.m_InputGateBias) : nullptr;
+    }
+
+    if (m_Param.m_ProjectionEnabled)
+    {
+        layer->m_ProjectionParameters.m_ProjectionWeights = m_ProjectionParameters.m_ProjectionWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_ProjectionParameters.m_ProjectionWeights) : nullptr;
+        layer->m_ProjectionParameters.m_ProjectionBias = m_ProjectionParameters.m_ProjectionBias ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_ProjectionParameters.m_ProjectionBias) : nullptr;
+    }
+
+    if (m_Param.m_PeepholeEnabled)
+    {
+        if (!m_Param.m_CifgEnabled) {
+            layer->m_PeepholeParameters.m_CellToInputWeights = m_PeepholeParameters.m_CellToInputWeights ?
+                    std::make_unique<ScopedCpuTensorHandle>(*m_PeepholeParameters.m_CellToInputWeights) : nullptr;
+        }
+
+        layer->m_PeepholeParameters.m_CellToForgetWeights = m_PeepholeParameters.m_CellToForgetWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_PeepholeParameters.m_CellToForgetWeights) : nullptr;
+        layer->m_PeepholeParameters.m_CellToOutputWeights = m_PeepholeParameters.m_CellToOutputWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_PeepholeParameters.m_CellToOutputWeights) : nullptr;
+    }
+
+    if (m_Param.m_LayerNormEnabled)
+    {
+        if (!m_Param.m_CifgEnabled) {
+            layer->m_LayerNormParameters.m_InputLayerNormWeights = m_LayerNormParameters.m_InputLayerNormWeights ?
+                    std::make_unique<ScopedCpuTensorHandle>(*m_LayerNormParameters.m_InputLayerNormWeights) : nullptr;
+        }
+
+        layer->m_LayerNormParameters.m_ForgetLayerNormWeights = m_LayerNormParameters.m_ForgetLayerNormWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_LayerNormParameters.m_ForgetLayerNormWeights) : nullptr;
+        layer->m_LayerNormParameters.m_CellLayerNormWeights = m_LayerNormParameters.m_CellLayerNormWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_LayerNormParameters.m_CellLayerNormWeights) : nullptr;
+        layer->m_LayerNormParameters.m_OutputLayerNormWeights = m_LayerNormParameters.m_OutputLayerNormWeights ?
+                std::make_unique<ScopedCpuTensorHandle>(*m_LayerNormParameters.m_OutputLayerNormWeights) : nullptr;
+    }
+
+    return std::move(layer);
+}
+
+std::vector<TensorShape> QLstmLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
+{
+    BOOST_ASSERT(inputShapes.size() == 3);
+
+    // Get input values for validation
+    unsigned int batchSize = inputShapes[0][0];
+    unsigned int outputSize = inputShapes[1][1];
+    unsigned int numUnits = inputShapes[2][1];
+
+    std::vector<TensorShape> outShapes;
+    outShapes.push_back(TensorShape({ batchSize, outputSize })); // outputStateOut
+    outShapes.push_back(TensorShape({ batchSize, numUnits })); // cellStateOut
+    outShapes.push_back(TensorShape({ batchSize, outputSize })); // output
+
+    return outShapes;
+}
+
+void QLstmLayer::ValidateTensorShapesFromInputs()
+{
+    VerifyLayerConnections(3, CHECK_LOCATION());
+
+    auto inferredShapes = InferOutputShapes(
+    {
+        GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(), // input
+        GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape(), // previousOutputIn
+        GetInputSlot(2).GetConnection()->GetTensorInfo().GetShape() //  previousCellStateIn
+    });
+
+    BOOST_ASSERT(inferredShapes.size() == 3);
+
+    // Check if the weights are nullptr for basic params
+    BOOST_ASSERT_MSG(m_BasicParameters.m_InputToForgetWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_InputToForgetWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_InputToCellWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_InputToCellWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_InputToOutputWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_InputToOutputWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToForgetWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_RecurrentToForgetWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToCellWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_RecurrentToCellWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToOutputWeights != nullptr,
+            "QLstmLayer: m_BasicParameters.m_RecurrentToOutputWeights should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_ForgetGateBias != nullptr,
+            "QLstmLayer: m_BasicParameters.m_ForgetGateBias should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_CellBias != nullptr,
+            "QLstmLayer: m_BasicParameters.m_CellBias should not be null.");
+    BOOST_ASSERT_MSG(m_BasicParameters.m_OutputGateBias != nullptr,
+            "QLstmLayer: m_BasicParameters.m_OutputGateBias should not be null.");
+
+    if (!m_Param.m_CifgEnabled)
+    {
+        BOOST_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights != nullptr,
+                "QLstmLayer: m_CifgParameters.m_InputToInputWeights should not be null.");
+        BOOST_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights != nullptr,
+                "QLstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not be null.");
+        BOOST_ASSERT_MSG(m_CifgParameters.m_InputGateBias != nullptr,
+                "QLstmLayer: m_CifgParameters.m_InputGateBias should not be null.");
+
+        ConditionalThrowIfNotEqual<LayerValidationException>(
+                "QLstmLayer: TensorShape set on OutputSlot[0] does not match the inferred shape.",
+                GetOutputSlot(0).GetTensorInfo().GetShape(),
+                inferredShapes[0]);
+    }
+    else
+    {
+        BOOST_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights == nullptr,
+                "QLstmLayer: m_CifgParameters.m_InputToInputWeights should not have a value when CIFG is enabled.");
+        BOOST_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights == nullptr,
+                "QLstmLayer: m_CifgParameters.m_RecurrentToInputWeights should "
+                             "not have a value when CIFG is enabled.");
+        BOOST_ASSERT_MSG(m_CifgParameters.m_InputGateBias == nullptr,
+                "QLstmLayer: m_CifgParameters.m_InputGateBias should not have a value when CIFG is enabled.");
+
+        ConditionalThrowIfNotEqual<LayerValidationException>(
+                "QLstmLayer: TensorShape set on OutputSlot[0] does not match the inferred shape.",
+                GetOutputSlot(0).GetTensorInfo().GetShape(),
+                inferredShapes[0]);
+    }
+
+    if (m_Param.m_ProjectionEnabled)
+    {
+        BOOST_ASSERT_MSG(m_ProjectionParameters.m_ProjectionWeights != nullptr,
+                         "QLstmLayer: m_ProjectionParameters.m_ProjectionWeights should not be null.");
+        BOOST_ASSERT_MSG(m_ProjectionParameters.m_ProjectionBias != nullptr,
+                         "QLstmLayer: m_ProjectionParameters.m_ProjectionBias should not be null.");
+    }
+
+    if (m_Param.m_PeepholeEnabled)
+    {
+        if (!m_Param.m_CifgEnabled) {
+            BOOST_ASSERT_MSG(m_PeepholeParameters.m_CellToInputWeights != nullptr,
+                    "QLstmLayer: m_PeepholeParameters.m_CellToInputWeights should not be null "
+                    "when Peephole is enabled and CIFG is disabled.");
+        }
+
+        BOOST_ASSERT_MSG(m_PeepholeParameters.m_CellToForgetWeights != nullptr,
+                         "QLstmLayer: m_PeepholeParameters.m_CellToForgetWeights should not be null.");
+        BOOST_ASSERT_MSG(m_PeepholeParameters.m_CellToOutputWeights != nullptr,
+                         "QLstmLayer: m_PeepholeParameters.m_CellToOutputWeights should not be null.");
+    }
+
+    ConditionalThrowIfNotEqual<LayerValidationException>(
+            "QLstmLayer: TensorShape set on OutputSlot[1] does not match the inferred shape.",
+            GetOutputSlot(1).GetTensorInfo().GetShape(),
+            inferredShapes[1]);
+    ConditionalThrowIfNotEqual<LayerValidationException>(
+            "QLstmLayer: TensorShape set on OutputSlot[2] does not match the inferred shape.",
+            GetOutputSlot(2).GetTensorInfo().GetShape(),
+            inferredShapes[2]);
+
+    if (m_Param.m_LayerNormEnabled)
+    {
+        if(!m_Param.m_CifgEnabled)
+        {
+            BOOST_ASSERT_MSG(m_LayerNormParameters.m_InputLayerNormWeights != nullptr,
+                             "QLstmLayer: m_LayerNormParameters.m_InputLayerNormWeights should not be null.");
+        }
+        BOOST_ASSERT_MSG(m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr,
+                         "QLstmLayer: m_LayerNormParameters.m_ForgetLayerNormWeights should not be null.");
+        BOOST_ASSERT_MSG(m_LayerNormParameters.m_CellLayerNormWeights != nullptr,
+                         "QLstmLayer: m_LayerNormParameters.m_CellLayerNormWeights should not be null.");
+        BOOST_ASSERT_MSG(m_LayerNormParameters.m_OutputLayerNormWeights != nullptr,
+                         "QLstmLayer: m_LayerNormParameters.m_UutputLayerNormWeights should not be null.");
+    }
+}
+
+Layer::ConstantTensors QLstmLayer::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 QLstmLayer::Accept(ILayerVisitor& visitor) const
+{
+    LstmInputParams inputParams;
+
+    ConstTensor inputToInputWeightsTensor;
+    if (m_CifgParameters.m_InputToInputWeights != nullptr)
+    {
+        ConstTensor inputToInputWeightsTensorCopy(m_CifgParameters.m_InputToInputWeights->GetTensorInfo(),
+                                                  m_CifgParameters.m_InputToInputWeights->Map(true));
+        inputToInputWeightsTensor = inputToInputWeightsTensorCopy;
+        inputParams.m_InputToInputWeights = &inputToInputWeightsTensor;
+    }
+
+    ConstTensor inputToForgetWeightsTensor;
+    if (m_BasicParameters.m_InputToForgetWeights != nullptr)
+    {
+        ConstTensor inputToForgetWeightsTensorCopy(m_BasicParameters.m_InputToForgetWeights->GetTensorInfo(),
+                                                   m_BasicParameters.m_InputToForgetWeights->Map(true));
+        inputToForgetWeightsTensor = inputToForgetWeightsTensorCopy;
+        inputParams.m_InputToForgetWeights = &inputToForgetWeightsTensor;
+    }
+
+    ConstTensor inputToCellWeightsTensor;
+    if (m_BasicParameters.m_InputToCellWeights != nullptr)
+    {
+        ConstTensor inputToCellWeightsTensorCopy(m_BasicParameters.m_InputToCellWeights->GetTensorInfo(),
+                                                 m_BasicParameters.m_InputToCellWeights->Map(true));
+        inputToCellWeightsTensor = inputToCellWeightsTensorCopy;
+        inputParams.m_InputToCellWeights = &inputToCellWeightsTensor;
+    }
+
+    ConstTensor inputToOutputWeightsTensor;
+    if (m_BasicParameters.m_InputToOutputWeights != nullptr)
+    {
+        ConstTensor inputToOutputWeightsTensorCopy(m_BasicParameters.m_InputToOutputWeights->GetTensorInfo(),
+                                                   m_BasicParameters.m_InputToOutputWeights->Map(true));
+        inputToOutputWeightsTensor = inputToOutputWeightsTensorCopy;
+        inputParams.m_InputToOutputWeights = &inputToOutputWeightsTensor;
+    }
+
+    ConstTensor recurrentToInputWeightsTensor;
+    if (m_CifgParameters.m_RecurrentToInputWeights != nullptr)
+    {
+        ConstTensor recurrentToInputWeightsTensorCopy(
+                m_CifgParameters.m_RecurrentToInputWeights->GetTensorInfo(),
+                m_CifgParameters.m_RecurrentToInputWeights->Map(true));
+        recurrentToInputWeightsTensor = recurrentToInputWeightsTensorCopy;
+        inputParams.m_RecurrentToInputWeights = &recurrentToInputWeightsTensor;
+    }
+
+    ConstTensor recurrentToForgetWeightsTensor;
+    if (m_BasicParameters.m_RecurrentToForgetWeights != nullptr)
+    {
+        ConstTensor recurrentToForgetWeightsTensorCopy(
+                m_BasicParameters.m_RecurrentToForgetWeights->GetTensorInfo(),
+                m_BasicParameters.m_RecurrentToForgetWeights->Map(true));
+        recurrentToForgetWeightsTensor = recurrentToForgetWeightsTensorCopy;
+        inputParams.m_RecurrentToForgetWeights = &recurrentToForgetWeightsTensor;
+    }
+
+    ConstTensor recurrentToCellWeightsTensor;
+    if (m_BasicParameters.m_RecurrentToCellWeights != nullptr)
+    {
+        ConstTensor recurrentToCellWeightsTensorCopy(
+                m_BasicParameters.m_RecurrentToCellWeights->GetTensorInfo(),
+                m_BasicParameters.m_RecurrentToCellWeights->Map(true));
+        recurrentToCellWeightsTensor = recurrentToCellWeightsTensorCopy;
+        inputParams.m_RecurrentToCellWeights = &recurrentToCellWeightsTensor;
+    }
+
+    ConstTensor recurrentToOutputWeightsTensor;
+    if (m_BasicParameters.m_RecurrentToOutputWeights != nullptr)
+    {
+        ConstTensor recurrentToOutputWeightsTensorCopy(
+                m_BasicParameters.m_RecurrentToOutputWeights->GetTensorInfo(),
+                m_BasicParameters.m_RecurrentToOutputWeights->Map(true));
+        recurrentToOutputWeightsTensor = recurrentToOutputWeightsTensorCopy;
+        inputParams.m_RecurrentToOutputWeights = &recurrentToOutputWeightsTensor;
+    }
+
+    ConstTensor cellToInputWeightsTensor;
+    if (m_PeepholeParameters.m_CellToInputWeights != nullptr)
+    {
+        ConstTensor cellToInputWeightsTensorCopy(m_PeepholeParameters.m_CellToInputWeights->GetTensorInfo(),
+                                                 m_PeepholeParameters.m_CellToInputWeights->Map(true));
+        cellToInputWeightsTensor = cellToInputWeightsTensorCopy;
+        inputParams.m_CellToInputWeights = &cellToInputWeightsTensor;
+    }
+
+    ConstTensor cellToForgetWeightsTensor;
+    if (m_PeepholeParameters.m_CellToForgetWeights != nullptr)
+    {
+        ConstTensor cellToForgetWeightsTensorCopy(m_PeepholeParameters.m_CellToForgetWeights->GetTensorInfo(),
+                                                  m_PeepholeParameters.m_CellToForgetWeights->Map(true));
+        cellToForgetWeightsTensor = cellToForgetWeightsTensorCopy;
+        inputParams.m_CellToForgetWeights = &cellToForgetWeightsTensor;
+    }
+
+    ConstTensor cellToOutputWeightsTensor;
+    if (m_PeepholeParameters.m_CellToOutputWeights != nullptr)
+    {
+        ConstTensor cellToOutputWeightsTensorCopy(m_PeepholeParameters.m_CellToOutputWeights->GetTensorInfo(),
+                                                  m_PeepholeParameters.m_CellToOutputWeights->Map(true));
+        cellToOutputWeightsTensor = cellToOutputWeightsTensorCopy;
+        inputParams.m_CellToOutputWeights = &cellToOutputWeightsTensor;
+    }
+
+    ConstTensor inputGateBiasTensor;
+    if (m_CifgParameters.m_InputGateBias != nullptr)
+    {
+        ConstTensor inputGateBiasTensorCopy(m_CifgParameters.m_InputGateBias->GetTensorInfo(),
+                                            m_CifgParameters.m_InputGateBias->Map(true));
+        inputGateBiasTensor = inputGateBiasTensorCopy;
+        inputParams.m_InputGateBias = &inputGateBiasTensor;
+    }
+
+    ConstTensor forgetGateBiasTensor;
+    if (m_BasicParameters.m_ForgetGateBias != nullptr)
+    {
+        ConstTensor forgetGateBiasTensorCopy(m_BasicParameters.m_ForgetGateBias->GetTensorInfo(),
+                                             m_BasicParameters.m_ForgetGateBias->Map(true));
+        forgetGateBiasTensor = forgetGateBiasTensorCopy;
+        inputParams.m_ForgetGateBias = &forgetGateBiasTensor;
+    }
+
+    ConstTensor cellBiasTensor;
+    if (m_BasicParameters.m_CellBias != nullptr)
+    {
+        ConstTensor cellBiasTensorCopy(m_BasicParameters.m_CellBias->GetTensorInfo(),
+                                       m_BasicParameters.m_CellBias->Map(true));
+        cellBiasTensor = cellBiasTensorCopy;
+        inputParams.m_CellBias = &cellBiasTensor;
+    }
+
+    ConstTensor outputGateBias;
+    if (m_BasicParameters.m_OutputGateBias != nullptr)
+    {
+        ConstTensor outputGateBiasCopy(m_BasicParameters.m_OutputGateBias->GetTensorInfo(),
+                                       m_BasicParameters.m_OutputGateBias->Map(true));
+        outputGateBias = outputGateBiasCopy;
+        inputParams.m_OutputGateBias = &outputGateBias;
+    }
+
+    ConstTensor projectionWeightsTensor;
+    if (m_ProjectionParameters.m_ProjectionWeights != nullptr)
+    {
+        ConstTensor projectionWeightsTensorCopy(m_ProjectionParameters.m_ProjectionWeights->GetTensorInfo(),
+                                                m_ProjectionParameters.m_ProjectionWeights->Map(true));
+        projectionWeightsTensor = projectionWeightsTensorCopy;
+        inputParams.m_ProjectionWeights = &projectionWeightsTensor;
+    }
+
+    ConstTensor projectionBiasTensor;
+    if (m_ProjectionParameters.m_ProjectionBias != nullptr)
+    {
+        ConstTensor projectionBiasTensorCopy(m_ProjectionParameters.m_ProjectionBias->GetTensorInfo(),
+                                             m_ProjectionParameters.m_ProjectionBias->Map(true));
+        projectionBiasTensor = projectionBiasTensorCopy;
+        inputParams.m_ProjectionBias = &projectionBiasTensor;
+    }
+
+    ConstTensor inputLayerNormTensor;
+    if (m_LayerNormParameters.m_InputLayerNormWeights != nullptr)
+    {
+        ConstTensor inputLayerNormTensorCopy(m_LayerNormParameters.m_InputLayerNormWeights->GetTensorInfo(),
+                                             m_LayerNormParameters.m_InputLayerNormWeights->Map(true));
+        inputLayerNormTensor = inputLayerNormTensorCopy;
+        inputParams.m_InputLayerNormWeights = &inputLayerNormTensor;
+    }
+
+    ConstTensor forgetLayerNormTensor;
+    if (m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr)
+    {
+        ConstTensor forgetLayerNormTensorCopy(m_LayerNormParameters.m_ForgetLayerNormWeights->GetTensorInfo(),
+                                              m_LayerNormParameters.m_ForgetLayerNormWeights->Map(true));
+        forgetLayerNormTensor = forgetLayerNormTensorCopy;
+        inputParams.m_ForgetLayerNormWeights = &forgetLayerNormTensor;
+    }
+
+    ConstTensor cellLayerNormTensor;
+    if (m_LayerNormParameters.m_CellLayerNormWeights != nullptr)
+    {
+        ConstTensor cellLayerNormTensorCopy(m_LayerNormParameters.m_CellLayerNormWeights->GetTensorInfo(),
+                                            m_LayerNormParameters.m_CellLayerNormWeights->Map(true));
+        cellLayerNormTensor = cellLayerNormTensorCopy;
+        inputParams.m_CellLayerNormWeights = &cellLayerNormTensor;
+    }
+
+    ConstTensor outputLayerNormTensor;
+    if (m_LayerNormParameters.m_OutputLayerNormWeights != nullptr)
+    {
+        ConstTensor outputLayerNormTensorCopy(m_LayerNormParameters.m_OutputLayerNormWeights->GetTensorInfo(),
+                                              m_LayerNormParameters.m_OutputLayerNormWeights->Map(true));
+        outputLayerNormTensor = outputLayerNormTensorCopy;
+        inputParams.m_OutputLayerNormWeights = &outputLayerNormTensor;
+    }
+
+
+    visitor.VisitQLstmLayer(this, GetParameters(), inputParams, GetName());
+}
+
+} // namespace armnn
diff --git a/src/armnn/layers/QLstmLayer.hpp b/src/armnn/layers/QLstmLayer.hpp
new file mode 100644
index 0000000000..2d40b7e29e
--- /dev/null
+++ b/src/armnn/layers/QLstmLayer.hpp
@@ -0,0 +1,124 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+class ScopedCpuTensorHandle;
+
+struct QLstmBasicParameters
+{
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputToForgetWeights;
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputToCellWeights;
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, inputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputToOutputWeights;
+
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToForgetWeights;
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToCellWeights;
+    /// A unique pointer to represent 2D weights tensor with dimensions [num_units, outputSize] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToOutputWeights;
+
+    /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32).
+    std::unique_ptr<ScopedCpuTensorHandle> m_ForgetGateBias;
+    /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32).
+    std::unique_ptr<ScopedCpuTensorHandle> m_CellBias;
+    /// A unique pointer to represent 1D bias tensor with dimensions [num_units] (int32).
+    std::unique_ptr<ScopedCpuTensorHandle> m_OutputGateBias;
+};
+
+struct QLstmOptProjectionParameters
+{
+    /// A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_ProjectionWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [output_size] (int32).
+    std::unique_ptr<ScopedCpuTensorHandle> m_ProjectionBias;
+};
+
+struct QLstmOptPeepholeParameters
+{
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_CellToInputWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_CellToForgetWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_CellToOutputWeights;
+};
+
+struct QLstmOptCifgParameters
+{
+    /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputToInputWeights;
+    /// A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units] (QSymmS8).
+    std::unique_ptr<ScopedCpuTensorHandle> m_RecurrentToInputWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (int32).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputGateBias;
+};
+
+struct QLstmOptLayerNormParameters
+{
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_InputLayerNormWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_ForgetLayerNormWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_CellLayerNormWeights;
+    /// A unique pointer to represent 1D weights tensor with dimensions [num_units] (QSymmS16).
+    std::unique_ptr<ScopedCpuTensorHandle> m_OutputLayerNormWeights;
+};
+
+/// This layer represents a QLstm operation.
+class QLstmLayer : public LayerWithParameters<QLstmDescriptor>
+{
+public:
+
+    QLstmBasicParameters m_BasicParameters;
+    QLstmOptCifgParameters m_CifgParameters;
+    QLstmOptProjectionParameters m_ProjectionParameters;
+    QLstmOptPeepholeParameters m_PeepholeParameters;
+    QLstmOptLayerNormParameters m_LayerNormParameters;
+
+    /// Makes a workload for the QLstm type.
+    /// @param [in] graph The graph where this layer can be found.
+    /// @param [in] factory The workload factory which will create the workload.
+    /// @return A pointer to the created workload, or nullptr if not created.
+    virtual std::unique_ptr<IWorkload> CreateWorkload(const IWorkloadFactory& factory) const override;
+
+    /// Creates a dynamically-allocated copy of this layer.
+    /// @param [in] graph The graph into which this layer is being cloned.
+    QLstmLayer* Clone(Graph& graph) const override;
+
+    /// Check if the input tensor shape(s)
+    /// will lead to a valid configuration of @ref QLstmLayer.
+    void ValidateTensorShapesFromInputs() 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.
+    /// @param [in] inputShapes The input shapes layer has.
+    /// @return A vector to the inferred output shape.
+    std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;
+
+    void Accept(ILayerVisitor& visitor) const override;
+
+protected:
+    /// Constructor to create a QLstmLayer.
+    /// @param [in] name Optional name for the layer.
+    QLstmLayer(const QLstmDescriptor& param, const char* name);
+
+    /// Default destructor
+    ~QLstmLayer() = default;
+
+    /// Retrieve the handles to the constant values stored by the layer.
+    /// @return A vector of the constant tensors stored by this layer.
+    Layer::ConstantTensors GetConstantTensorsByRef() override;
+};
+
+} // namespace armnn