From 6f92c8e9f8bb38dcf5dccf8deeff5112ecd8e37c Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Wed, 22 Nov 2023 11:41:15 +0000 Subject: Update Doxygen for 23.11 Signed-off-by: Nikhil Raj Change-Id: I47cd933f5002cb94a73aa97689d7b3d9c93cb849 --- 23.11/_cl_lstm_float_workload_8cpp_source.html | 613 +++++++++++++++++++++++++ 1 file changed, 613 insertions(+) create mode 100644 23.11/_cl_lstm_float_workload_8cpp_source.html (limited to '23.11/_cl_lstm_float_workload_8cpp_source.html') diff --git a/23.11/_cl_lstm_float_workload_8cpp_source.html b/23.11/_cl_lstm_float_workload_8cpp_source.html new file mode 100644 index 0000000000..428934226c --- /dev/null +++ b/23.11/_cl_lstm_float_workload_8cpp_source.html @@ -0,0 +1,613 @@ + + + + + + + + +Arm NN: src/backends/cl/workloads/ClLstmFloatWorkload.cpp Source File + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  23.11 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
ClLstmFloatWorkload.cpp
+
+
+Go to the documentation of this file.
1 //
+
2 // Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
+
3 // SPDX-License-Identifier: MIT
+
4 //
+
5 
+
6 #include "ClLstmFloatWorkload.hpp"
+
7 #include <cl/ClTensorHandle.hpp>
+
8 #include <armnn/backends/TensorHandle.hpp>
+
9 #include <cl/ClLayerSupport.hpp>
+
10 #include <aclCommon/ArmComputeUtils.hpp>
+
11 #include <aclCommon/ArmComputeTensorUtils.hpp>
+
12 
+
13 #include <armnn/utility/NumericCast.hpp>
+
14 
+
15 #include <arm_compute/runtime/CL/functions/CLLSTMLayer.h>
+
16 
+
17 #include "ClWorkloadUtils.hpp"
+
18 
+
19 namespace armnn
+
20 {
+
21 using namespace armcomputetensorutils;
+
22 
+
23 ClLstmFloatWorkload::ClLstmFloatWorkload(const LstmQueueDescriptor& descriptor,
+
24  const WorkloadInfo& info,
+
25  const arm_compute::CLCompileContext& clCompileContext)
+
26  : FloatWorkload<LstmQueueDescriptor>(descriptor, info)
+
27 {
+
28  // Report Profiling Details
+
29  ARMNN_REPORT_PROFILING_WORKLOAD_DESC("ClLstmFloatWorkload_Construct",
+
30  descriptor.m_Parameters,
+
31  info,
+
32  GetGuid());
+
33 
+
34  arm_compute::LSTMParams<arm_compute::ICLTensor> lstm_param;
+
35 
+
36  // Basic parameters
+
37  m_InputToForgetWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
38  BuildArmComputeTensor(*m_InputToForgetWeightsTensor, m_Data.m_InputToForgetWeights->GetTensorInfo());
+
39 
+
40  m_InputToCellWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
41  BuildArmComputeTensor(*m_InputToCellWeightsTensor, m_Data.m_InputToCellWeights->GetTensorInfo());
+
42 
+
43  m_InputToOutputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
44  BuildArmComputeTensor(*m_InputToOutputWeightsTensor, m_Data.m_InputToOutputWeights->GetTensorInfo());
+
45 
+
46  m_RecurrentToForgetWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
47  BuildArmComputeTensor(*m_RecurrentToForgetWeightsTensor, m_Data.m_RecurrentToForgetWeights->GetTensorInfo());
+
48 
+
49  m_RecurrentToCellWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
50  BuildArmComputeTensor(*m_RecurrentToCellWeightsTensor, m_Data.m_RecurrentToCellWeights->GetTensorInfo());
+
51 
+
52  m_RecurrentToOutputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
53  BuildArmComputeTensor(*m_RecurrentToOutputWeightsTensor, m_Data.m_RecurrentToOutputWeights->GetTensorInfo());
+
54 
+
55  m_ForgetGateBiasTensor = std::make_unique<arm_compute::CLTensor>();
+
56  BuildArmComputeTensor(*m_ForgetGateBiasTensor, m_Data.m_ForgetGateBias->GetTensorInfo());
+
57 
+
58  m_CellBiasTensor = std::make_unique<arm_compute::CLTensor>();
+
59  BuildArmComputeTensor(*m_CellBiasTensor, m_Data.m_CellBias->GetTensorInfo());
+
60 
+
61  m_OutputGateBiasTensor = std::make_unique<arm_compute::CLTensor>();
+
62  BuildArmComputeTensor(*m_OutputGateBiasTensor, m_Data.m_OutputGateBias->GetTensorInfo());
+
63 
+
64  // for future reference: check the AndroidNN API for the logic here
+
65  if (!m_Data.m_Parameters.m_CifgEnabled)
+
66  {
+
67  m_InputToInputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
68  BuildArmComputeTensor(*m_InputToInputWeightsTensor, m_Data.m_InputToInputWeights->GetTensorInfo());
+
69 
+
70  m_RecurrentToInputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
71  BuildArmComputeTensor(*m_RecurrentToInputWeightsTensor, m_Data.m_RecurrentToInputWeights->GetTensorInfo());
+
72 
+
73  m_CellToInputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
74  if (m_Data.m_CellToInputWeights != nullptr)
+
75  {
+
76  BuildArmComputeTensor(*m_CellToInputWeightsTensor, m_Data.m_CellToInputWeights->GetTensorInfo());
+
77  }
+
78 
+
79  m_InputGateBiasTensor = std::make_unique<arm_compute::CLTensor>();
+
80  BuildArmComputeTensor(*m_InputGateBiasTensor, m_Data.m_InputGateBias->GetTensorInfo());
+
81 
+
82  lstm_param.set_cifg_params(m_InputToInputWeightsTensor.get(),
+
83  m_RecurrentToInputWeightsTensor.get(),
+
84  m_Data.m_CellToInputWeights != nullptr ? m_CellToInputWeightsTensor.get() : nullptr,
+
85  m_InputGateBiasTensor.get());
+
86  }
+
87 
+
88  if (m_Data.m_Parameters.m_ProjectionEnabled)
+
89  {
+
90  m_ProjectionWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
91  BuildArmComputeTensor(*m_ProjectionWeightsTensor, m_Data.m_ProjectionWeights->GetTensorInfo());
+
92 
+
93  m_ProjectionBiasTensor = std::make_unique<arm_compute::CLTensor>();
+
94  if (m_Data.m_ProjectionBias != nullptr)
+
95  {
+
96  BuildArmComputeTensor(*m_ProjectionBiasTensor, m_Data.m_ProjectionBias->GetTensorInfo());
+
97  }
+
98 
+
99  lstm_param.set_projection_params(m_ProjectionWeightsTensor.get(),
+
100  m_Data.m_ProjectionBias != nullptr ? m_ProjectionBiasTensor.get() : nullptr);
+
101  }
+
102 
+
103  if (m_Data.m_Parameters.m_PeepholeEnabled)
+
104  {
+
105  m_CellToForgetWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
106  BuildArmComputeTensor(*m_CellToForgetWeightsTensor, m_Data.m_CellToForgetWeights->GetTensorInfo());
+
107 
+
108  m_CellToOutputWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
109  BuildArmComputeTensor(*m_CellToOutputWeightsTensor, m_Data.m_CellToOutputWeights->GetTensorInfo());
+
110 
+
111  lstm_param.set_peephole_params(m_CellToForgetWeightsTensor.get(), m_CellToOutputWeightsTensor.get());
+
112  }
+
113 
+
114  if (m_Data.m_Parameters.m_LayerNormEnabled)
+
115  {
+
116  m_InputLayerNormWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
117  m_ForgetLayerNormWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
118  m_CellLayerNormWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
119  m_OutputLayerNormWeightsTensor = std::make_unique<arm_compute::CLTensor>();
+
120 
+
121  if (!m_Data.m_Parameters.m_CifgEnabled)
+
122  {
+
123  BuildArmComputeTensor(*m_InputLayerNormWeightsTensor, m_Data.m_InputLayerNormWeights->GetTensorInfo());
+
124  }
+
125  BuildArmComputeTensor(*m_ForgetLayerNormWeightsTensor, m_Data.m_ForgetLayerNormWeights->GetTensorInfo());
+
126  BuildArmComputeTensor(*m_CellLayerNormWeightsTensor, m_Data.m_CellLayerNormWeights->GetTensorInfo());
+
127  BuildArmComputeTensor(*m_OutputLayerNormWeightsTensor, m_Data.m_OutputLayerNormWeights->GetTensorInfo());
+
128 
+
129  lstm_param.set_layer_normalization_params(m_Data.m_Parameters.m_CifgEnabled ? nullptr :
+
130  m_InputLayerNormWeightsTensor.get(),
+
131  m_ForgetLayerNormWeightsTensor.get(),
+
132  m_CellLayerNormWeightsTensor.get(),
+
133  m_OutputLayerNormWeightsTensor.get());
+
134  }
+
135 
+
136  const arm_compute::ICLTensor& input = static_cast<IClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+
137  const arm_compute::ICLTensor& output_state_in = static_cast<IClTensorHandle*>(m_Data.m_Inputs[1])->GetTensor();
+
138  arm_compute::ICLTensor& cell_state_in = static_cast<IClTensorHandle*>(m_Data.m_Inputs[2])->GetTensor();
+
139 
+
140  arm_compute::ICLTensor& output_state_out = static_cast<IClTensorHandle*>(m_Data.m_Outputs[1])->GetTensor();
+
141  arm_compute::ICLTensor& cell_state_out = static_cast<IClTensorHandle*>(m_Data.m_Outputs[2])->GetTensor();
+
142  arm_compute::ICLTensor& output = static_cast<IClTensorHandle*>(m_Data.m_Outputs[3])->GetTensor();
+
143 
+
144  // Get the batch_size and the num_units from the cellStateIn dimensions
+
145  const TensorInfo& inputTensorInfo = info.m_InputTensorInfos[2];
+
146  const unsigned int batch_size = armnn::numeric_cast<unsigned int>(inputTensorInfo.GetShape()[0]);
+
147  const unsigned int num_units = armnn::numeric_cast<unsigned int>(inputTensorInfo.GetShape()[1]);
+
148 
+
149  m_ScratchBuffer = std::make_unique<arm_compute::CLTensor>();
+
150  if (m_Data.m_Parameters.m_CifgEnabled)
+
151  {
+
152  // 2D tensor with dimensions [num_units * 3, batch_size] with CIFG
+
153  armnn::TensorInfo scratchBuffer1({ batch_size, num_units * 3 }, DataType::Float32);
+
154  BuildArmComputeTensor(*m_ScratchBuffer, scratchBuffer1);
+
155  }
+
156  else
+
157  {
+
158  // scratch_buffer [num_units * 4, batch_size] without CIFG
+
159  armnn::TensorInfo scratchBuffer2({ batch_size, num_units * 4 }, DataType::Float32);
+
160  BuildArmComputeTensor(*m_ScratchBuffer, scratchBuffer2);
+
161  }
+
162 
+
163  float cell_threshold = m_Data.m_Parameters.m_ClippingThresCell;
+
164  float projection_threshold = m_Data.m_Parameters.m_ClippingThresProj;
+
165 
+
166  // for preparing the object for the class ActivationLayerInfo, we need to consider 5 situations
+
167  arm_compute::ActivationLayerInfo activationLayerInfo =
+
168  ConvertLstmActivationFuncToAclLayerInfo(m_Data.m_Parameters.m_ActivationFunc);
+
169 
+
170  {
+
171  ARMNN_SCOPED_PROFILING_EVENT_CL_NAME_GUID("ClLstmFloatWorkload_configure");
+
172  m_LstmLayer.configure(clCompileContext, &input, m_InputToForgetWeightsTensor.get(),
+
173  m_InputToCellWeightsTensor.get(), m_InputToOutputWeightsTensor.get(),
+
174  m_RecurrentToForgetWeightsTensor.get(), m_RecurrentToCellWeightsTensor.get(),
+
175  m_RecurrentToOutputWeightsTensor.get(), m_ForgetGateBiasTensor.get(),
+
176  m_CellBiasTensor.get(), m_OutputGateBiasTensor.get(), &output_state_in,
+
177  &cell_state_in, m_ScratchBuffer.get(), &output_state_out,
+
178  &cell_state_out, &output, lstm_param, activationLayerInfo,
+
179  cell_threshold, projection_threshold);
+
180  }
+
181 
+
182  armcomputetensorutils::InitialiseArmComputeTensorEmpty(*m_ScratchBuffer);
+
183 
+
184  InitializeArmComputeClTensorData(*m_InputToForgetWeightsTensor, m_Data.m_InputToForgetWeights);
+
185  InitializeArmComputeClTensorData(*m_InputToCellWeightsTensor, m_Data.m_InputToCellWeights);
+
186  InitializeArmComputeClTensorData(*m_InputToOutputWeightsTensor, m_Data.m_InputToOutputWeights);
+
187  InitializeArmComputeClTensorData(*m_RecurrentToForgetWeightsTensor, m_Data.m_RecurrentToForgetWeights);
+
188  InitializeArmComputeClTensorData(*m_RecurrentToCellWeightsTensor, m_Data.m_RecurrentToCellWeights);
+
189  InitializeArmComputeClTensorData(*m_RecurrentToOutputWeightsTensor, m_Data.m_RecurrentToOutputWeights);
+
190  InitializeArmComputeClTensorData(*m_ForgetGateBiasTensor, m_Data.m_ForgetGateBias);
+
191  InitializeArmComputeClTensorData(*m_CellBiasTensor, m_Data.m_CellBias);
+
192  InitializeArmComputeClTensorData(*m_OutputGateBiasTensor, m_Data.m_OutputGateBias);
+
193 
+
194  if (!m_Data.m_Parameters.m_CifgEnabled)
+
195  {
+
196  InitializeArmComputeClTensorData(*m_InputToInputWeightsTensor, m_Data.m_InputToInputWeights);
+
197  InitializeArmComputeClTensorData(*m_RecurrentToInputWeightsTensor, m_Data.m_RecurrentToInputWeights);
+
198  if (m_Data.m_CellToInputWeights != nullptr)
+
199  {
+
200  InitializeArmComputeClTensorData(*m_CellToInputWeightsTensor, m_Data.m_CellToInputWeights);
+
201  }
+
202  InitializeArmComputeClTensorData(*m_InputGateBiasTensor, m_Data.m_InputGateBias);
+
203  }
+
204 
+
205  if (m_Data.m_Parameters.m_ProjectionEnabled)
+
206  {
+
207  InitializeArmComputeClTensorData(*m_ProjectionWeightsTensor, m_Data.m_ProjectionWeights);
+
208  if (m_Data.m_ProjectionBias != nullptr)
+
209  {
+
210  InitializeArmComputeClTensorData(*m_ProjectionBiasTensor, m_Data.m_ProjectionBias);
+
211  }
+
212  }
+
213 
+
214  if (m_Data.m_Parameters.m_PeepholeEnabled)
+
215  {
+
216  InitializeArmComputeClTensorData(*m_CellToForgetWeightsTensor, m_Data.m_CellToForgetWeights);
+
217  InitializeArmComputeClTensorData(*m_CellToOutputWeightsTensor, m_Data.m_CellToOutputWeights);
+
218  }
+
219 
+
220  if (m_Data.m_Parameters.m_LayerNormEnabled)
+
221  {
+
222  if (!m_Data.m_Parameters.m_CifgEnabled)
+
223  {
+
224  InitializeArmComputeClTensorData(*m_InputLayerNormWeightsTensor, m_Data.m_InputLayerNormWeights);
+
225  }
+
226 
+
227  InitializeArmComputeClTensorData(*m_ForgetLayerNormWeightsTensor, m_Data.m_ForgetLayerNormWeights);
+
228  InitializeArmComputeClTensorData(*m_CellLayerNormWeightsTensor, m_Data.m_CellLayerNormWeights);
+
229  InitializeArmComputeClTensorData(*m_OutputLayerNormWeightsTensor, m_Data.m_OutputLayerNormWeights);
+
230  }
+
231 
+
232  // Force Compute Library to perform the necessary copying and reshaping, after which
+
233  // delete all the input tensors that will no longer be needed
+
234  m_LstmLayer.prepare();
+
235  FreeUnusedTensors();
+
236 }
+
237 
+
238 void ClLstmFloatWorkload::Execute() const
+
239 {
+
240  ARMNN_SCOPED_PROFILING_EVENT_CL_NAME_GUID("ClLstmFloatWorkload_Execute");
+
241  RunClFunction(m_LstmLayer, CHECK_LOCATION());
+
242 }
+
243 
+
244 arm_compute::Status ClLstmFloatWorkloadValidate(const TensorInfo& input, const TensorInfo& outputStateIn,
+
245  const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
+
246  const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
+
247  const TensorInfo& output, const LstmDescriptor& descriptor,
+
248  const LstmInputParamsInfo& paramsInfo)
+
249 {
+
250  arm_compute::LSTMParams<arm_compute::ITensorInfo> lstm_params_info;
+
251 
+
252  // The inputs and the outputs
+
253  const arm_compute::TensorInfo aclInputInfo = BuildArmComputeTensorInfo(input);
+
254  const arm_compute::TensorInfo aclOutputStateInInfo = BuildArmComputeTensorInfo(outputStateIn);
+
255  const arm_compute::TensorInfo aclCellStateInInfo = BuildArmComputeTensorInfo(cellStateIn);
+
256  const arm_compute::TensorInfo aclScratchBufferInfo = BuildArmComputeTensorInfo(scratchBuffer);
+
257  const arm_compute::TensorInfo aclOutputStateOutInfo = BuildArmComputeTensorInfo(outputStateOut);
+
258  const arm_compute::TensorInfo aclCellStateOutInfo = BuildArmComputeTensorInfo(cellStateOut);
+
259  const arm_compute::TensorInfo aclOutputInfo = BuildArmComputeTensorInfo(output);
+
260 
+
261  // Basic parameters
+
262  const arm_compute::TensorInfo aclInputToForgetWeightsInfo
+
263  = BuildArmComputeTensorInfo(paramsInfo.GetInputToForgetWeights());
+
264  const arm_compute::TensorInfo aclInputToCellWeightsInfo
+
265  = BuildArmComputeTensorInfo(paramsInfo.GetInputToCellWeights());
+
266  const arm_compute::TensorInfo aclInputToOutputWeightsInfo
+
267  = BuildArmComputeTensorInfo(paramsInfo.GetInputToOutputWeights());
+
268  const arm_compute::TensorInfo aclRecurrentToForgetWeightsInfo
+
269  = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToForgetWeights());
+
270  const arm_compute::TensorInfo aclRecurrentToCellWeightsInfo
+
271  = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToCellWeights());
+
272  const arm_compute::TensorInfo aclRecurrentToOutputWeightsInfo
+
273  = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToOutputWeights());
+
274  const arm_compute::TensorInfo aclForgetGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetGateBias());
+
275  const arm_compute::TensorInfo aclCellBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellBias());
+
276  const arm_compute::TensorInfo aclOutputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputGateBias());
+
277 
+
278  arm_compute::TensorInfo aclInputToInputWeightsInfo;
+
279  arm_compute::TensorInfo aclRecurrentToInputWeightsInfo;
+
280  arm_compute::TensorInfo aclCellToInputWeightsInfo;
+
281  arm_compute::TensorInfo aclInputGateBiasInfo;
+
282  arm_compute::TensorInfo aclProjectionWeightsInfo;
+
283  arm_compute::TensorInfo aclProjectionBiasInfo;
+
284  arm_compute::TensorInfo aclCellToForgetWeightsInfo;
+
285  arm_compute::TensorInfo aclCellToOutputWeightsInfo;
+
286  arm_compute::TensorInfo aclInputLayerNormWeightsInfo;
+
287  arm_compute::TensorInfo aclForgetLayerNormWeightsInfo;
+
288  arm_compute::TensorInfo aclCellLayerNormWeightsInfo;
+
289  arm_compute::TensorInfo aclOutputLayerNormWeightsInfo;
+
290 
+
291  if (!descriptor.m_CifgEnabled)
+
292  {
+
293  aclInputToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputToInputWeights());
+
294  aclRecurrentToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetRecurrentToInputWeights());
+
295 
+
296  if (paramsInfo.m_CellToInputWeights != nullptr)
+
297  {
+
298  aclCellToInputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToInputWeights());
+
299  }
+
300  aclInputGateBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputGateBias());
+
301  lstm_params_info.set_cifg_params(&aclInputToInputWeightsInfo, &aclRecurrentToInputWeightsInfo,
+
302  paramsInfo.m_CellToInputWeights != nullptr ?
+
303  &aclCellToInputWeightsInfo: nullptr,
+
304  &aclInputGateBiasInfo);
+
305  }
+
306 
+
307  if (descriptor.m_ProjectionEnabled)
+
308  {
+
309  aclProjectionWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionWeights());
+
310 
+
311  if (paramsInfo.m_ProjectionBias != nullptr)
+
312  {
+
313  aclProjectionBiasInfo = BuildArmComputeTensorInfo(paramsInfo.GetProjectionBias());
+
314  }
+
315  lstm_params_info.set_projection_params(&aclProjectionWeightsInfo,
+
316  paramsInfo.m_ProjectionBias != nullptr ?
+
317  &aclProjectionBiasInfo: nullptr);
+
318  }
+
319 
+
320  if (descriptor.m_PeepholeEnabled)
+
321  {
+
322  aclCellToForgetWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToForgetWeights());
+
323  aclCellToOutputWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellToOutputWeights());
+
324  lstm_params_info.set_peephole_params(&aclCellToForgetWeightsInfo, &aclCellToOutputWeightsInfo);
+
325  }
+
326 
+
327  float cell_threshold = descriptor.m_ClippingThresCell;
+
328  float projection_threshold = descriptor.m_ClippingThresProj;
+
329 
+
330  // for preparing the object for the class ActivationLayerInfo, we need to consider 5 situations
+
331  arm_compute::ActivationLayerInfo activationLayerInfo =
+
332  ConvertLstmActivationFuncToAclLayerInfo(descriptor.m_ActivationFunc);
+
333 
+
334  if (descriptor.m_LayerNormEnabled)
+
335  {
+
336  if (!descriptor.m_CifgEnabled)
+
337  {
+
338  aclInputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetInputLayerNormWeights());
+
339  }
+
340 
+
341  aclForgetLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetForgetLayerNormWeights());
+
342 
+
343  aclCellLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetCellLayerNormWeights());
+
344 
+
345  aclOutputLayerNormWeightsInfo = BuildArmComputeTensorInfo(paramsInfo.GetOutputLayerNormWeights());
+
346 
+
347  lstm_params_info.set_layer_normalization_params(descriptor.m_CifgEnabled ?
+
348  nullptr : &aclInputLayerNormWeightsInfo,
+
349  &aclForgetLayerNormWeightsInfo,
+
350  &aclCellLayerNormWeightsInfo,
+
351  &aclOutputLayerNormWeightsInfo);
+
352  }
+
353 
+
354  return arm_compute::CLLSTMLayer::validate(&aclInputInfo, &aclInputToForgetWeightsInfo,
+
355  &aclInputToCellWeightsInfo,
+
356  &aclInputToOutputWeightsInfo,
+
357  &aclRecurrentToForgetWeightsInfo,
+
358  &aclRecurrentToCellWeightsInfo,
+
359  &aclRecurrentToOutputWeightsInfo,
+
360  &aclForgetGateBiasInfo,
+
361  &aclCellBiasInfo,
+
362  &aclOutputGateBiasInfo,
+
363  &aclOutputStateInInfo, &aclCellStateInInfo,
+
364  &aclScratchBufferInfo, &aclOutputStateOutInfo,
+
365  &aclCellStateOutInfo, &aclOutputInfo,
+
366  lstm_params_info, activationLayerInfo,
+
367  cell_threshold, projection_threshold);
+
368 }
+
369 
+
370 void ClLstmFloatWorkload::FreeUnusedTensors()
+
371 {
+
372  FreeTensorIfUnused(m_InputToInputWeightsTensor);
+
373  FreeTensorIfUnused(m_InputToForgetWeightsTensor);
+
374  FreeTensorIfUnused(m_InputToCellWeightsTensor);
+
375  FreeTensorIfUnused(m_InputToOutputWeightsTensor);
+
376  FreeTensorIfUnused(m_RecurrentToInputWeightsTensor);
+
377  FreeTensorIfUnused(m_RecurrentToForgetWeightsTensor);
+
378  FreeTensorIfUnused(m_RecurrentToCellWeightsTensor);
+
379  FreeTensorIfUnused(m_RecurrentToOutputWeightsTensor);
+
380  FreeTensorIfUnused(m_CellToInputWeightsTensor);
+
381  FreeTensorIfUnused(m_CellToForgetWeightsTensor);
+
382  FreeTensorIfUnused(m_CellToOutputWeightsTensor);
+
383  FreeTensorIfUnused(m_InputGateBiasTensor);
+
384  FreeTensorIfUnused(m_ForgetGateBiasTensor);
+
385  FreeTensorIfUnused(m_CellBiasTensor);
+
386  FreeTensorIfUnused(m_OutputGateBiasTensor);
+
387  FreeTensorIfUnused(m_ProjectionWeightsTensor);
+
388  FreeTensorIfUnused(m_ProjectionBiasTensor);
+
389  FreeTensorIfUnused(m_ScratchBuffer);
+
390  FreeTensorIfUnused(m_InputLayerNormWeightsTensor);
+
391  FreeTensorIfUnused(m_ForgetLayerNormWeightsTensor);
+
392  FreeTensorIfUnused(m_CellLayerNormWeightsTensor);
+
393  FreeTensorIfUnused(m_OutputLayerNormWeightsTensor);
+
394 }
+
395 
+
396 void ClLstmFloatWorkload::ReplaceInputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot)
+
397 {
+
398  ITensorHandle* backupHandle = this->m_Data.m_Inputs[slot];
+
399  this->m_Data.m_Inputs[slot] = tensorHandle;
+
400  try
+
401  {
+
402  Reconfigure();
+
403  }
+
404  catch(armnn::UnimplementedException& e)
+
405  {
+
406  // Cannot reconfigure, revert the slot back and throw the exception.
+
407  this->m_Data.m_Inputs[slot] = backupHandle;
+
408  throw e;
+
409  }
+
410 }
+
411 
+
412 // Replace output tensor handle with the given TensorHandle
+
413 void ClLstmFloatWorkload::ReplaceOutputTensorHandle(ITensorHandle* tensorHandle, unsigned int slot)
+
414 {
+
415  ITensorHandle* backupHandle = this->m_Data.m_Inputs[slot];
+
416  this->m_Data.m_Inputs[slot] = tensorHandle;
+
417  try
+
418  {
+
419  Reconfigure();
+
420  }
+
421  catch(armnn::UnimplementedException& e)
+
422  {
+
423  // Cannot reconfigure, revert the slot back and throw the exception.
+
424  this->m_Data.m_Inputs[slot] = backupHandle;
+
425  throw e;
+
426  }
+
427 }
+
428 
+
429 void ClLstmFloatWorkload::Reconfigure()
+
430 {
+
431  throw armnn::UnimplementedException("Reconfigure not implemented for this workload");
+
432 }
+
433 
+
434 } //namespace armnn
+
+
+
armnn::RunClFunction
void RunClFunction(arm_compute::IFunction &function, const CheckLocation &location)
Definition: ClWorkloadUtils.hpp:168
+
armnn::LstmInputParamsInfo::GetCellBias
const TensorInfo & GetCellBias() const
Definition: LstmParams.hpp:173
+
armnn::LstmInputParamsInfo::GetInputToCellWeights
const TensorInfo & GetInputToCellWeights() const
Definition: LstmParams.hpp:129
+ + +
armnn::LstmInputParamsInfo::GetProjectionBias
const TensorInfo & GetProjectionBias() const
Definition: LstmParams.hpp:185
+
CHECK_LOCATION
#define CHECK_LOCATION()
Definition: Exceptions.hpp:203
+
armnn::ClLstmFloatWorkload::ReplaceOutputTensorHandle
void ReplaceOutputTensorHandle(ITensorHandle *tensorHandle, unsigned int slot) override
Definition: ClLstmFloatWorkload.cpp:413
+ +
armnn::LstmInputParamsInfo::m_CellToInputWeights
const TensorInfo * m_CellToInputWeights
Definition: LstmParams.hpp:97
+ +
armnn::LstmInputParamsInfo::GetInputGateBias
const TensorInfo & GetInputGateBias() const
Definition: LstmParams.hpp:165
+
armnn::LstmInputParamsInfo::GetRecurrentToInputWeights
const TensorInfo & GetRecurrentToInputWeights() const
Definition: LstmParams.hpp:137
+
armnn::LstmInputParamsInfo::GetRecurrentToForgetWeights
const TensorInfo & GetRecurrentToForgetWeights() const
Definition: LstmParams.hpp:141
+ +
armnn::LstmInputParamsInfo::GetRecurrentToCellWeights
const TensorInfo & GetRecurrentToCellWeights() const
Definition: LstmParams.hpp:145
+ +
armnn::LstmInputParamsInfo::GetInputLayerNormWeights
const TensorInfo & GetInputLayerNormWeights() const
Definition: LstmParams.hpp:189
+
armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1148
+
armnn::LstmDescriptor::m_ClippingThresProj
float m_ClippingThresProj
Clipping threshold value for the projection.
Definition: Descriptors.hpp:1144
+ +
armnn::LstmInputParamsInfo::GetCellToInputWeights
const TensorInfo & GetCellToInputWeights() const
Definition: LstmParams.hpp:153
+
armnn::LstmInputParamsInfo::GetRecurrentToOutputWeights
const TensorInfo & GetRecurrentToOutputWeights() const
Definition: LstmParams.hpp:149
+
armnn::LstmInputParamsInfo::GetInputToInputWeights
const TensorInfo & GetInputToInputWeights() const
Definition: LstmParams.hpp:121
+
ARMNN_SCOPED_PROFILING_EVENT_CL_NAME_GUID
#define ARMNN_SCOPED_PROFILING_EVENT_CL_NAME_GUID(label)
Creates a profiling event that uses GetGuid() and GetName() from the calling class.
Definition: ClWorkloadUtils.hpp:36
+
armnn::WorkloadInfo
Contains information about TensorInfos of a layer.
Definition: WorkloadInfo.hpp:16
+
armnn::LstmInputParamsInfo::GetForgetGateBias
const TensorInfo & GetForgetGateBias() const
Definition: LstmParams.hpp:169
+ +
armnn::ConvertLstmActivationFuncToAclLayerInfo
arm_compute::ActivationLayerInfo ConvertLstmActivationFuncToAclLayerInfo(uint32_t activationFunction)
Definition: ArmComputeUtils.hpp:118
+
armnn::LstmInputParamsInfo::GetCellToForgetWeights
const TensorInfo & GetCellToForgetWeights() const
Definition: LstmParams.hpp:157
+ + + +
armnn::ClLstmFloatWorkloadValidate
arm_compute::Status ClLstmFloatWorkloadValidate(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &scratchBuffer, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const LstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo)
Definition: ClLstmFloatWorkload.cpp:244
+ +
armnn::InitializeArmComputeClTensorData
void InitializeArmComputeClTensorData(arm_compute::CLTensor &clTensor, const ConstTensorHandle *handle)
Definition: ClWorkloadUtils.hpp:124
+
armnn::QueueDescriptor::m_Outputs
std::vector< ITensorHandle * > m_Outputs
Definition: WorkloadData.hpp:27
+
ARMNN_REPORT_PROFILING_WORKLOAD_DESC
#define ARMNN_REPORT_PROFILING_WORKLOAD_DESC(name, desc, infos, guid)
Definition: Profiling.hpp:227
+
armnn::BaseWorkload::GetGuid
arm::pipe::ProfilingGuid GetGuid() const final
Definition: Workload.hpp:67
+ +
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1102
+ + +
armnn::Status
Status
Definition: Types.hpp:42
+ +
armnn::LstmInputParamsInfo::GetInputToOutputWeights
const TensorInfo & GetInputToOutputWeights() const
Definition: LstmParams.hpp:133
+
armnn::LstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
Definition: Descriptors.hpp:1146
+
armnn::BaseWorkload::m_Data
QueueDescriptor m_Data
Definition: Workload.hpp:89
+
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:191
+
armnn::LstmInputParamsInfo::GetOutputGateBias
const TensorInfo & GetOutputGateBias() const
Definition: LstmParams.hpp:177
+
armnn::LstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:1152
+
armnn::LstmInputParamsInfo::GetCellToOutputWeights
const TensorInfo & GetCellToOutputWeights() const
Definition: LstmParams.hpp:161
+
armnn::LstmInputParamsInfo::GetOutputLayerNormWeights
const TensorInfo & GetOutputLayerNormWeights() const
Definition: LstmParams.hpp:201
+
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
+ +
armnn::ClLstmFloatWorkload::ReplaceInputTensorHandle
void ReplaceInputTensorHandle(ITensorHandle *tensorHandle, unsigned int slot) override
Definition: ClLstmFloatWorkload.cpp:396
+ +
armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1150
+
armnn::LstmInputParamsInfo::GetProjectionWeights
const TensorInfo & GetProjectionWeights() const
Definition: LstmParams.hpp:181
+ +
armnn::LstmDescriptor::m_ActivationFunc
uint32_t m_ActivationFunc
The activation function to use.
Definition: Descriptors.hpp:1140
+
armnn::LstmDescriptor::m_ClippingThresCell
float m_ClippingThresCell
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:1142
+
armnn::ClLstmFloatWorkload::ClLstmFloatWorkload
ClLstmFloatWorkload(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info, const arm_compute::CLCompileContext &clCompileContext)
Definition: ClLstmFloatWorkload.cpp:23
+
armnn::LstmInputParamsInfo::m_ProjectionBias
const TensorInfo * m_ProjectionBias
Definition: LstmParams.hpp:105
+
armnn::LstmInputParamsInfo::GetForgetLayerNormWeights
const TensorInfo & GetForgetLayerNormWeights() const
Definition: LstmParams.hpp:193
+
armnn::LstmInputParamsInfo::GetCellLayerNormWeights
const TensorInfo & GetCellLayerNormWeights() const
Definition: LstmParams.hpp:197
+
armnn::QueueDescriptor::m_Inputs
std::vector< ITensorHandle * > m_Inputs
Definition: WorkloadData.hpp:26
+
armnn::LstmInputParamsInfo::GetInputToForgetWeights
const TensorInfo & GetInputToForgetWeights() const
Definition: LstmParams.hpp:125
+ + + + -- cgit v1.2.1