| // |
| // Copyright © 2017 Arm Ltd. All rights reserved. |
| // SPDX-License-Identifier: MIT |
| // |
| #include "LstmLayer.hpp" |
| |
| #include "LayerCloneBase.hpp" |
| |
| #include <armnn/TypesUtils.hpp> |
| #include <backendsCommon/CpuTensorHandle.hpp> |
| #include <backendsCommon/WorkloadFactory.hpp> |
| |
| namespace armnn |
| { |
| |
| LstmLayer::LstmLayer(const LstmDescriptor& param, const char* name) |
| : LayerWithParameters(3, 4, LayerType::Lstm, param, name) |
| { |
| } |
| |
| std::unique_ptr<IWorkload> LstmLayer::CreateWorkload(const Graph& graph, const IWorkloadFactory& factory) const |
| { |
| LstmQueueDescriptor 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_CellToInputWeights = m_CifgParameters.m_CellToInputWeights.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) |
| { |
| 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.CreateLstm(descriptor, PrepInfoAndDesc(descriptor, graph)); |
| } |
| |
| LstmLayer* LstmLayer::Clone(Graph& graph) const |
| { |
| auto layer = CloneBase<LstmLayer>(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_CellToInputWeights = m_CifgParameters.m_CellToInputWeights ? |
| std::make_unique<ScopedCpuTensorHandle>(*m_CifgParameters.m_CellToInputWeights) : 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) |
| { |
| 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) |
| { |
| 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> LstmLayer::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, numUnits * (m_Param.m_CifgEnabled ? 3 : 4)})); |
| outShapes.push_back(TensorShape({batchSize, outputSize})); |
| outShapes.push_back(TensorShape({batchSize, numUnits})); |
| outShapes.push_back(TensorShape({batchSize, outputSize})); |
| |
| return outShapes; |
| } |
| |
| void LstmLayer::ValidateTensorShapesFromInputs() |
| { |
| VerifyLayerConnections(3, CHECK_LOCATION()); |
| |
| auto inferredShapes = InferOutputShapes( { |
| GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(), |
| GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape(), |
| GetInputSlot(2).GetConnection()->GetTensorInfo().GetShape()} |
| ); |
| |
| BOOST_ASSERT(inferredShapes.size() == 4); |
| |
| // Check if the weights are nullptr |
| BOOST_ASSERT_MSG(m_BasicParameters.m_InputToForgetWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_InputToForgetWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_InputToCellWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_InputToCellWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_InputToOutputWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_InputToOutputWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToForgetWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_RecurrentToForgetWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToCellWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_RecurrentToCellWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_RecurrentToOutputWeights != nullptr, |
| "LstmLayer: m_BasicParameters.m_RecurrentToOutputWeights should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_ForgetGateBias != nullptr, |
| "LstmLayer: m_BasicParameters.m_ForgetGateBias should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_CellBias != nullptr, |
| "LstmLayer: m_BasicParameters.m_CellBias should not be null."); |
| BOOST_ASSERT_MSG(m_BasicParameters.m_OutputGateBias != nullptr, |
| "LstmLayer: m_BasicParameters.m_OutputGateBias should not be null."); |
| |
| if (!m_Param.m_CifgEnabled) |
| { |
| BOOST_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights != nullptr, |
| "LstmLayer: m_CifgParameters.m_InputToInputWeights should not be null."); |
| BOOST_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights != nullptr, |
| "LstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not be null."); |
| BOOST_ASSERT_MSG(m_CifgParameters.m_InputGateBias != nullptr, |
| "LstmLayer: m_CifgParameters.m_InputGateBias should not be null."); |
| |
| ConditionalThrowIfNotEqual<LayerValidationException>( |
| "LstmLayer: 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, |
| "LstmLayer: m_CifgParameters.m_InputToInputWeights should not have a value when CIFG is enabled."); |
| BOOST_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights == nullptr, |
| "LstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not have a value when CIFG is enabled."); |
| BOOST_ASSERT_MSG(m_CifgParameters.m_CellToInputWeights == nullptr, |
| "LstmLayer: m_CifgParameters.m_CellToInputWeights should not have a value when CIFG is enabled."); |
| BOOST_ASSERT_MSG(m_CifgParameters.m_InputGateBias == nullptr, |
| "LstmLayer: m_CifgParameters.m_InputGateBias should not have a value when CIFG is enabled."); |
| |
| ConditionalThrowIfNotEqual<LayerValidationException>( |
| "LstmLayer: 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, |
| "LstmLayer: m_ProjectionParameters.m_ProjectionWeights should not be null."); |
| } |
| |
| if (m_Param.m_PeepholeEnabled) |
| { |
| BOOST_ASSERT_MSG(m_PeepholeParameters.m_CellToForgetWeights != nullptr, |
| "LstmLayer: m_PeepholeParameters.m_CellToForgetWeights should not be null."); |
| BOOST_ASSERT_MSG(m_PeepholeParameters.m_CellToOutputWeights != nullptr, |
| "LstmLayer: m_PeepholeParameters.m_CellToOutputWeights should not be null."); |
| } |
| |
| ConditionalThrowIfNotEqual<LayerValidationException>( |
| "LstmLayer: TensorShape set on OutputSlot[1] does not match the inferred shape.", |
| GetOutputSlot(1).GetTensorInfo().GetShape(), |
| inferredShapes[1]); |
| ConditionalThrowIfNotEqual<LayerValidationException>( |
| "LstmLayer: TensorShape set on OutputSlot[2] does not match the inferred shape.", |
| GetOutputSlot(2).GetTensorInfo().GetShape(), |
| inferredShapes[2]); |
| ConditionalThrowIfNotEqual<LayerValidationException>( |
| "LstmLayer: TensorShape set on OutputSlot[3] does not match the inferred shape.", |
| GetOutputSlot(3).GetTensorInfo().GetShape(), |
| inferredShapes[3]); |
| |
| if (m_Param.m_LayerNormEnabled) |
| { |
| if(!m_Param.m_CifgEnabled) |
| { |
| BOOST_ASSERT_MSG(m_LayerNormParameters.m_InputLayerNormWeights != nullptr, |
| "LstmLayer: m_LayerNormParameters.m_inputLayerNormWeights should not be null."); |
| } |
| BOOST_ASSERT_MSG(m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr, |
| "LstmLayer: m_LayerNormParameters.m_forgetLayerNormWeights should not be null."); |
| BOOST_ASSERT_MSG(m_LayerNormParameters.m_CellLayerNormWeights != nullptr, |
| "LstmLayer: m_LayerNormParameters.m_cellLayerNormWeights should not be null."); |
| BOOST_ASSERT_MSG(m_LayerNormParameters.m_OutputLayerNormWeights != nullptr, |
| "LstmLayer: m_LayerNormParameters.m_outputLayerNormWeights should not be null."); |
| } |
| } |
| |
| Layer::ConstantTensors LstmLayer::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_CellToInputWeights, |
| m_CifgParameters.m_InputGateBias, |
| |
| // Projection parameters |
| m_ProjectionParameters.m_ProjectionWeights, |
| m_ProjectionParameters.m_ProjectionBias, |
| |
| // Peephole parameters |
| 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 LstmLayer::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_CifgParameters.m_CellToInputWeights != nullptr) |
| { |
| ConstTensor cellToInputWeightsTensorCopy(m_CifgParameters.m_CellToInputWeights->GetTensorInfo(), |
| m_CifgParameters.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.VisitLstmLayer(this, GetParameters(), inputParams, GetName()); |
| } |
| |
| } // namespace armnn |
