From 8efb48a6847c5cd166c561127ae6611150963ce3 Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Fri, 19 May 2023 11:14:28 +0100 Subject: Update Doxygen docu for 23.05 Signed-off-by: Nikhil Raj Change-Id: I0a992286f14fa68fcc6e5eba31ac39fed003cbbe --- ...assarmnn_1_1_neon_quantized_lstm_workload.xhtml | 382 +++++++++++++++++++++ 1 file changed, 382 insertions(+) create mode 100644 23.05/classarmnn_1_1_neon_quantized_lstm_workload.xhtml (limited to '23.05/classarmnn_1_1_neon_quantized_lstm_workload.xhtml') diff --git a/23.05/classarmnn_1_1_neon_quantized_lstm_workload.xhtml b/23.05/classarmnn_1_1_neon_quantized_lstm_workload.xhtml new file mode 100644 index 0000000000..6f1622ee6f --- /dev/null +++ b/23.05/classarmnn_1_1_neon_quantized_lstm_workload.xhtml @@ -0,0 +1,382 @@ + + + + + + + + + + + + + +ArmNN: NeonQuantizedLstmWorkload Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  23.05 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Public Member Functions | +List of all members
+
+
NeonQuantizedLstmWorkload Class Reference
+
+
+ +

#include <NeonQuantizedLstmWorkload.hpp>

+
+Inheritance diagram for NeonQuantizedLstmWorkload:
+
+
+ + +NeonBaseWorkload< QuantizedLstmQueueDescriptor > +BaseWorkload< QuantizedLstmQueueDescriptor > +IWorkload + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 NeonQuantizedLstmWorkload (const QuantizedLstmQueueDescriptor &descriptor, const WorkloadInfo &info)
 
virtual void Execute () const override
 
- Public Member Functions inherited from NeonBaseWorkload< QuantizedLstmQueueDescriptor >
 NeonBaseWorkload (const QuantizedLstmQueueDescriptor &descriptor, const WorkloadInfo &info)
 
void ReplaceInputTensorHandle (ITensorHandle *tensorHandle, unsigned int slot) override
 
void ReplaceOutputTensorHandle (ITensorHandle *tensorHandle, unsigned int slot) override
 
- Public Member Functions inherited from BaseWorkload< QuantizedLstmQueueDescriptor >
 BaseWorkload (const QuantizedLstmQueueDescriptor &descriptor, const WorkloadInfo &info)
 
void ExecuteAsync (ExecutionData &executionData) override
 
void PostAllocationConfigure () override
 
const QuantizedLstmQueueDescriptor & GetData () const
 
arm::pipe::ProfilingGuid GetGuid () const final
 
virtual bool SupportsTensorHandleReplacement () const override
 
- Public Member Functions inherited from IWorkload
virtual ~IWorkload ()
 
virtual arm::pipe::ProfilingGuid GetGuid () const =0
 
virtual bool SupportsTensorHandleReplacement () const =0
 
virtual void RegisterDebugCallback (const DebugCallbackFunction &)
 
virtual armnn::Optional< armnn::MemoryRequirements > GetMemoryRequirements ()
 
+ + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from NeonBaseWorkload< QuantizedLstmQueueDescriptor >
virtual void Reconfigure ()
 
- Protected Attributes inherited from BaseWorkload< QuantizedLstmQueueDescriptor >
QuantizedLstmQueueDescriptor m_Data
 
const arm::pipe::ProfilingGuid m_Guid
 
+

Detailed Description

+
+

Definition at line 18 of file NeonQuantizedLstmWorkload.hpp.

+

Constructor & Destructor Documentation

+ +

◆ NeonQuantizedLstmWorkload()

+ +
+
+ + + + + + + + + + + + + + + + + + +
NeonQuantizedLstmWorkload (const QuantizedLstmQueueDescriptor & descriptor,
const WorkloadInfo & info 
)
+
+ +

Definition at line 17 of file NeonQuantizedLstmWorkload.cpp.

+
19  : NeonBaseWorkload<QuantizedLstmQueueDescriptor>(descriptor, info)
+
20 {
+
21  // Basic parameters
+
22  m_InputToInputWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
23  BuildArmComputeTensor(*m_InputToInputWeightsTensor, m_Data.m_InputToInputWeights->GetTensorInfo());
+
24 
+
25  m_InputToForgetWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
26  BuildArmComputeTensor(*m_InputToForgetWeightsTensor, m_Data.m_InputToForgetWeights->GetTensorInfo());
+
27 
+
28  m_InputToCellWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
29  BuildArmComputeTensor(*m_InputToCellWeightsTensor, m_Data.m_InputToCellWeights->GetTensorInfo());
+
30 
+
31  m_InputToOutputWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
32  BuildArmComputeTensor(*m_InputToOutputWeightsTensor, m_Data.m_InputToOutputWeights->GetTensorInfo());
+
33 
+
34  m_RecurrentToInputWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
35  BuildArmComputeTensor(*m_RecurrentToInputWeightsTensor, m_Data.m_RecurrentToInputWeights->GetTensorInfo());
+
36 
+
37  m_RecurrentToForgetWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
38  BuildArmComputeTensor(*m_RecurrentToForgetWeightsTensor, m_Data.m_RecurrentToForgetWeights->GetTensorInfo());
+
39 
+
40  m_RecurrentToCellWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
41  BuildArmComputeTensor(*m_RecurrentToCellWeightsTensor, m_Data.m_RecurrentToCellWeights->GetTensorInfo());
+
42 
+
43  m_RecurrentToOutputWeightsTensor = std::make_unique<arm_compute::Tensor>();
+
44  BuildArmComputeTensor(*m_RecurrentToOutputWeightsTensor, m_Data.m_RecurrentToOutputWeights->GetTensorInfo());
+
45 
+
46  m_InputGateBiasTensor = std::make_unique<arm_compute::Tensor>();
+
47  BuildArmComputeTensor(*m_InputGateBiasTensor, m_Data.m_InputGateBias->GetTensorInfo());
+
48 
+
49  m_ForgetGateBiasTensor = std::make_unique<arm_compute::Tensor>();
+
50  BuildArmComputeTensor(*m_ForgetGateBiasTensor, m_Data.m_ForgetGateBias->GetTensorInfo());
+
51 
+
52  m_CellBiasTensor = std::make_unique<arm_compute::Tensor>();
+
53  BuildArmComputeTensor(*m_CellBiasTensor, m_Data.m_CellBias->GetTensorInfo());
+
54 
+
55  m_OutputGateBiasTensor = std::make_unique<arm_compute::Tensor>();
+
56  BuildArmComputeTensor(*m_OutputGateBiasTensor, m_Data.m_OutputGateBias->GetTensorInfo());
+
57 
+
58  const arm_compute::ITensor& input = static_cast<IAclTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+
59  arm_compute::ITensor& cell_state_in = static_cast<IAclTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
+
60  const arm_compute::ITensor& output_state_in = static_cast<IAclTensorHandle*>(m_Data.m_Inputs[2])->GetTensor();
+
61 
+
62  arm_compute::ITensor& cell_state_out = static_cast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
+
63  arm_compute::ITensor& output_state_out = static_cast<IAclTensorHandle*>(m_Data.m_Outputs[1])->GetTensor();
+
64 
+
65  m_QuantizedLstmLayer.configure(&input,
+
66  m_InputToInputWeightsTensor.get(),
+
67  m_InputToForgetWeightsTensor.get(),
+
68  m_InputToCellWeightsTensor.get(),
+
69  m_InputToOutputWeightsTensor.get(),
+
70  m_RecurrentToInputWeightsTensor.get(),
+
71  m_RecurrentToForgetWeightsTensor.get(),
+
72  m_RecurrentToCellWeightsTensor.get(),
+
73  m_RecurrentToOutputWeightsTensor.get(),
+
74  m_InputGateBiasTensor.get(),
+
75  m_ForgetGateBiasTensor.get(),
+
76  m_CellBiasTensor.get(),
+
77  m_OutputGateBiasTensor.get(),
+
78  &cell_state_in,
+
79  &output_state_in,
+
80  &cell_state_out,
+
81  &output_state_out);
+
82 
+
83  InitializeArmComputeTensorData(*m_InputToInputWeightsTensor,
+
84  m_Data.m_InputToInputWeights);
+
85 
+
86  InitializeArmComputeTensorData(*m_InputToForgetWeightsTensor,
+
87  m_Data.m_InputToForgetWeights);
+
88 
+
89  InitializeArmComputeTensorData(*m_InputToCellWeightsTensor,
+
90  m_Data.m_InputToCellWeights);
+
91 
+
92  InitializeArmComputeTensorData(*m_InputToOutputWeightsTensor,
+
93  m_Data.m_InputToOutputWeights);
+
94 
+
95  InitializeArmComputeTensorData(*m_RecurrentToInputWeightsTensor,
+
96  m_Data.m_RecurrentToInputWeights);
+
97 
+
98  InitializeArmComputeTensorData(*m_RecurrentToForgetWeightsTensor,
+
99  m_Data.m_RecurrentToForgetWeights);
+
100 
+
101  InitializeArmComputeTensorData(*m_RecurrentToCellWeightsTensor,
+
102  m_Data.m_RecurrentToCellWeights);
+
103 
+
104  InitializeArmComputeTensorData(*m_RecurrentToOutputWeightsTensor,
+
105  m_Data.m_RecurrentToOutputWeights);
+
106 
+
107  InitializeArmComputeTensorData(*m_InputGateBiasTensor,
+
108  m_Data.m_InputGateBias);
+
109 
+
110  InitializeArmComputeTensorData(*m_ForgetGateBiasTensor,
+
111  m_Data.m_ForgetGateBias);
+
112 
+
113  InitializeArmComputeTensorData(*m_CellBiasTensor,
+
114  m_Data.m_CellBias);
+
115 
+
116  InitializeArmComputeTensorData(*m_OutputGateBiasTensor,
+
117  m_Data.m_OutputGateBias);
+
118 
+
119  // Force Compute Library to perform the necessary copying and reshaping, after which
+
120  // delete all the input tensors that will no longer be needed
+
121  m_QuantizedLstmLayer.prepare();
+
122  FreeUnusedTensors();
+
123 }
+
+

References armnn::info.

+ +
+
+

Member Function Documentation

+ +

◆ Execute()

+ +
+
+ + + + + +
+ + + + + + + +
void Execute () const
+ 		+overridevirtual
+
+ +

Implements IWorkload.

+ +

Definition at line 125 of file NeonQuantizedLstmWorkload.cpp.

+
126 {
+
127  ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID("NeonQuantizedLstmWorkload_Execute", this->GetGuid());
+
128  m_QuantizedLstmLayer.run();
+
129 }
+
+

References ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID, and BaseWorkload< QuantizedLstmQueueDescriptor >::GetGuid().

+ +
+
+
The documentation for this class was generated from the following files: +
+
+
armnn::BaseWorkload< QuantizedLstmQueueDescriptor >::GetGuid
arm::pipe::ProfilingGuid GetGuid() const final
Definition: Workload.hpp:61
+
armnn::QuantizedLstmQueueDescriptor::m_InputToInputWeights
const ConstTensorHandle * m_InputToInputWeights
Definition: WorkloadData.hpp:628
+ +
armnn::InitializeArmComputeTensorData
void InitializeArmComputeTensorData(arm_compute::Tensor &tensor, TensorInfo tensorInfo, const ITensorHandle *handle)
Definition: NeonWorkloadUtils.hpp:60
+
armnn::QuantizedLstmQueueDescriptor::m_CellBias
const ConstTensorHandle * m_CellBias
Definition: WorkloadData.hpp:640
+
ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID
#define ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID(name, guid)
Definition: NeonWorkloadUtils.hpp:24
+
armnn::QuantizedLstmQueueDescriptor::m_InputToForgetWeights
const ConstTensorHandle * m_InputToForgetWeights
Definition: WorkloadData.hpp:629
+
armnn::QuantizedLstmQueueDescriptor::m_InputToCellWeights
const ConstTensorHandle * m_InputToCellWeights
Definition: WorkloadData.hpp:630
+
armnn::QuantizedLstmQueueDescriptor::m_InputToOutputWeights
const ConstTensorHandle * m_InputToOutputWeights
Definition: WorkloadData.hpp:631
+
armnn::QuantizedLstmQueueDescriptor::m_RecurrentToOutputWeights
const ConstTensorHandle * m_RecurrentToOutputWeights
Definition: WorkloadData.hpp:636
+
armnn::ConstTensorHandle::GetTensorInfo
const TensorInfo & GetTensorInfo() const
Definition: TensorHandle.hpp:40
+
armnn::QuantizedLstmQueueDescriptor::m_OutputGateBias
const ConstTensorHandle * m_OutputGateBias
Definition: WorkloadData.hpp:641
+
armnn::QuantizedLstmQueueDescriptor::m_RecurrentToCellWeights
const ConstTensorHandle * m_RecurrentToCellWeights
Definition: WorkloadData.hpp:635
+
armnn::QueueDescriptor::m_Outputs
std::vector< ITensorHandle * > m_Outputs
Definition: WorkloadData.hpp:27
+
armnn::QuantizedLstmQueueDescriptor::m_RecurrentToInputWeights
const ConstTensorHandle * m_RecurrentToInputWeights
Definition: WorkloadData.hpp:633
+
armnn::QuantizedLstmQueueDescriptor::m_ForgetGateBias
const ConstTensorHandle * m_ForgetGateBias
Definition: WorkloadData.hpp:639
+
armnn::QuantizedLstmQueueDescriptor::m_InputGateBias
const ConstTensorHandle * m_InputGateBias
Definition: WorkloadData.hpp:638
+
armnn::QuantizedLstmQueueDescriptor::m_RecurrentToForgetWeights
const ConstTensorHandle * m_RecurrentToForgetWeights
Definition: WorkloadData.hpp:634
+
armnn::QueueDescriptor::m_Inputs
std::vector< ITensorHandle * > m_Inputs
Definition: WorkloadData.hpp:26
+ + + + -- cgit v1.2.1