1 //
2 // Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5
6 #include "HalPolicy.hpp"
7
8 #include <armnn/Optional.hpp>
9
10 #include "FullyConnected.hpp"
11 #include "Utils.hpp"
12
13 namespace armnn_driver
14 {
15 namespace hal_1_0
16 {
17
ConvertOperation(const Operation & operation,const Model & model,ConversionData & data)18 bool HalPolicy::ConvertOperation(const Operation& operation, const Model& model, ConversionData& data)
19 {
20 switch (operation.type)
21 {
22 case V1_0::OperationType::ADD:
23 return ConvertElementwiseBinary(operation, model, data, armnn::BinaryOperation::Add);
24 case V1_0::OperationType::AVERAGE_POOL_2D:
25 return ConvertAveragePool2d(operation, model, data);
26 case V1_0::OperationType::CONCATENATION:
27 return ConvertConcatenation(operation, model, data);
28 case V1_0::OperationType::CONV_2D:
29 return ConvertConv2d(operation, model, data);
30 case V1_0::OperationType::DEPTH_TO_SPACE:
31 return ConvertDepthToSpace(operation, model, data);
32 case V1_0::OperationType::DEPTHWISE_CONV_2D:
33 return ConvertDepthwiseConv2d(operation, model, data);
34 case V1_0::OperationType::DEQUANTIZE:
35 return ConvertDequantize(operation, model, data);
36 case V1_0::OperationType::FLOOR:
37 return ConvertFloor(operation, model, data);
38 case V1_0::OperationType::FULLY_CONNECTED:
39 return ConvertFullyConnected(operation, model, data);
40 case V1_0::OperationType::LOCAL_RESPONSE_NORMALIZATION:
41 return ConvertLocalResponseNormalization(operation, model, data);
42 case V1_0::OperationType::LOGISTIC:
43 return ConvertLogistic(operation, model, data);
44 case V1_0::OperationType::LSTM:
45 return ConvertLstm(operation, model, data);
46 case V1_0::OperationType::L2_NORMALIZATION:
47 return ConvertL2Normalization(operation, model, data);
48 case V1_0::OperationType::L2_POOL_2D:
49 return ConvertL2Pool2d(operation, model, data);
50 case V1_0::OperationType::MAX_POOL_2D:
51 return ConvertMaxPool2d(operation, model, data);
52 case V1_0::OperationType::MUL:
53 return ConvertElementwiseBinary(operation, model, data, armnn::BinaryOperation::Mul);
54 case V1_0::OperationType::RELU:
55 return ConvertReLu(operation, model, data);
56 case V1_0::OperationType::RELU1:
57 return ConvertReLu1(operation, model, data);
58 case V1_0::OperationType::RELU6:
59 return ConvertReLu6(operation, model, data);
60 case V1_0::OperationType::SOFTMAX:
61 return ConvertSoftmax(operation, model, data);
62 case V1_0::OperationType::SPACE_TO_DEPTH:
63 return ConvertSpaceToDepth(operation, model, data);
64 case V1_0::OperationType::TANH:
65 return ConvertTanH(operation, model, data);
66 case V1_0::OperationType::RESHAPE:
67 return ConvertReshape(operation, model, data);
68 case V1_0::OperationType::RESIZE_BILINEAR:
69 return ConvertResizeBilinear(operation, model, data);
70 default:
71 return Fail("%s: Operation type %s not supported in ArmnnDriver",
72 __func__, toString(operation.type).c_str());
73 }
74 }
75
ConvertAveragePool2d(const Operation & operation,const Model & model,ConversionData & data)76 bool HalPolicy::ConvertAveragePool2d(const Operation& operation, const Model& model, ConversionData& data)
77 {
78 ALOGV("hal_1_0::HalPolicy::ConvertAveragePool2d()");
79 return ConvertPooling2d<hal_1_0::HalPolicy>(operation, __func__, armnn::PoolingAlgorithm::Average, model, data);
80 }
81
ConvertConcatenation(const Operation & operation,const Model & model,ConversionData & data)82 bool HalPolicy::ConvertConcatenation(const Operation& operation, const Model& model, ConversionData& data)
83 {
84 ALOGV("hal_1_0::HalPolicy::ConvertConcatenation()");
85 return ::ConvertConcatenation<hal_1_0::HalPolicy>(operation, model, data);
86 }
87
ConvertConv2d(const Operation & operation,const Model & model,ConversionData & data)88 bool HalPolicy::ConvertConv2d(const Operation& operation, const Model& model, ConversionData& data)
89 {
90 ALOGV("hal_1_0::HalPolicy::ConvertConv2d()");
91 return ::ConvertConv2d<hal_1_0::HalPolicy>(operation, model, data);
92 }
93
ConvertDepthToSpace(const Operation & operation,const Model & model,ConversionData & data)94 bool HalPolicy::ConvertDepthToSpace(const Operation& operation, const Model& model, ConversionData& data)
95 {
96 ALOGV("hal_1_0::HalPolicy::ConvertDepthToSpace()");
97 return ::ConvertDepthToSpace<hal_1_0::HalPolicy>(operation, model, data);
98 }
99
ConvertDepthwiseConv2d(const Operation & operation,const Model & model,ConversionData & data)100 bool HalPolicy::ConvertDepthwiseConv2d(const Operation& operation, const Model& model, ConversionData& data)
101 {
102 ALOGV("hal_1_0::HalPolicy::ConvertDepthwiseConv2d()");
103 return ::ConvertDepthwiseConv2d<hal_1_0::HalPolicy>(operation, model, data);
104 }
105
ConvertDequantize(const Operation & operation,const Model & model,ConversionData & data)106 bool HalPolicy::ConvertDequantize(const Operation& operation, const Model& model, ConversionData& data)
107 {
108 ALOGV("hal_1_0::HalPolicy::ConvertDequantize()");
109 return ::ConvertDequantize<hal_1_0::HalPolicy>(operation, model, data);
110 }
111
ConvertElementwiseBinary(const Operation & operation,const Model & model,ConversionData & data,armnn::BinaryOperation binaryOperation)112 bool HalPolicy::ConvertElementwiseBinary(const Operation& operation,
113 const Model& model,
114 ConversionData& data,
115 armnn::BinaryOperation binaryOperation)
116 {
117 ALOGV("hal_1_0::HalPolicy::ConvertElementwiseBinary()");
118 return ::ConvertElementwiseBinary<hal_1_0::HalPolicy>(operation, model, data, binaryOperation);
119 }
120
ConvertFloor(const Operation & operation,const Model & model,ConversionData & data)121 bool HalPolicy::ConvertFloor(const Operation& operation, const Model& model, ConversionData& data)
122 {
123 ALOGV("hal_1_0::HalPolicy::ConvertFloor()");
124 return ::ConvertFloor<hal_1_0::HalPolicy>(operation, model, data);
125 }
126
ConvertFullyConnected(const Operation & operation,const Model & model,ConversionData & data)127 bool HalPolicy::ConvertFullyConnected(const Operation& operation, const Model& model, ConversionData& data)
128 {
129 ALOGV("hal_1_0::HalPolicy::ConvertFullyConnected()");
130 return ::ConvertFullyConnected<hal_1_0::HalPolicy>(operation, model, data);
131 }
132
ConvertLocalResponseNormalization(const Operation & operation,const Model & model,ConversionData & data)133 bool HalPolicy::ConvertLocalResponseNormalization(const Operation& operation,
134 const Model& model,
135 ConversionData& data)
136 {
137 ALOGV("hal_1_0::HalPolicy::ConvertLocalResponseNormalization()");
138 return ::ConvertLocalResponseNormalization<hal_1_0::HalPolicy>(operation, model, data);
139 }
140
ConvertLogistic(const Operation & operation,const Model & model,ConversionData & data)141 bool HalPolicy::ConvertLogistic(const Operation& operation, const Model& model, ConversionData& data)
142 {
143 ALOGV("hal_1_0::HalPolicy::ConvertLogistic()");
144 return ::ConvertLogistic<hal_1_0::HalPolicy>(operation, model, data);
145 }
146
ConvertLstm(const Operation & operation,const Model & model,ConversionData & data)147 bool HalPolicy::ConvertLstm(const Operation& operation, const Model& model, ConversionData& data)
148 {
149 ALOGV("hal_1_0::HalPolicy::ConvertLstm()");
150
151 // Inputs:
152 // 00: The input: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, input_size], where
153 // “batch_size” corresponds to the batching dimension, and “input_size” is the size of the input.
154 LayerInputHandle input = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 0, model, data);
155 if (!input.IsValid())
156 {
157 return Fail("%s: Could not read input 0: input", __func__);
158 }
159 // 18: The output state: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, output_size].
160 LayerInputHandle outputStateIn = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 18, model, data);
161 if (!outputStateIn.IsValid())
162 {
163 return Fail("%s: Could not read input 18: outputStateIn", __func__);
164 }
165 // 19: The cell state: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, num_units].
166 LayerInputHandle cellStateIn = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 19, model, data);
167 if (!cellStateIn.IsValid())
168 {
169 return Fail("%s: Could not read input 19: cellStateIn", __func__);
170 }
171
172 // Get the mandatory input tensors:
173 // 02: The input-to-forget weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
174 // [num_units, input_size].
175 const ConstTensorPin inputToForgetWeightsPin =
176 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 2, model, data);
177 // 03: The input-to-cell weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
178 // [num_units, input_size].
179 const ConstTensorPin inputToCellWeightsPin =
180 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 3, model, data);
181 // 04: The input-to-output weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
182 // [num_units, input_size].
183 const ConstTensorPin inputToOutputWeightsPin =
184 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 4, model, data);
185 // 06: The recurrent-to-forget weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
186 // [num_units, output_size].
187 const ConstTensorPin recurrentToForgetWeightsPin =
188 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 6, model, data);
189 // 07: The recurrent-to-cell weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
190 // [num_units, output_size].
191 const ConstTensorPin recurrentToCellWeightsPin =
192 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 7, model, data);
193 // 08: The recurrent-to-output weights: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
194 // [num_units, output_size].
195 const ConstTensorPin recurrentToOutputWeightsPin =
196 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 8, model, data);
197 // 13: The forget gate bias: A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
198 const ConstTensorPin forgetGateBiasPin =
199 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 13, model, data);
200 // 14: The cell bias: A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
201 const ConstTensorPin cellBiasPin =
202 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 14, model, data);
203 // 15: The output gate bias: A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
204 const ConstTensorPin outputGateBiasPin =
205 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation, 15, model, data);
206
207 if (!inputToForgetWeightsPin.IsValid() ||
208 !inputToCellWeightsPin.IsValid() ||
209 !inputToOutputWeightsPin.IsValid() ||
210 !recurrentToForgetWeightsPin.IsValid() ||
211 !recurrentToCellWeightsPin.IsValid() ||
212 !recurrentToOutputWeightsPin.IsValid() ||
213 !forgetGateBiasPin.IsValid() ||
214 !cellBiasPin.IsValid() ||
215 !outputGateBiasPin.IsValid())
216 {
217 return Fail("%s: Operation has invalid tensor inputs", __func__);
218 }
219
220 // Get the optional input tensors:
221 // 01: The input-to-input weights: Optional. A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
222 // [num_units, input_size], where “num_units” corresponds to the number of cell units.
223 const ConstTensorPin inputToInputWeightsPin =
224 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
225 1,
226 model,
227 data,
228 g_DontPermute,
229 nullptr,
230 true);
231
232 // 05: The recurrent-to-input weights: Optional. A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
233 // [num_units, output_size], where “output_size” corresponds to either the number of cell units (i.e.,
234 // “num_units”), or the second dimension of the “projection_weights”, if defined.
235 const ConstTensorPin recurrentToInputWeightsPin =
236 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
237 5,
238 model,
239 data,
240 g_DontPermute,
241 nullptr,
242 true);
243
244 // 09: The cell-to-input weights: Optional. A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
245 const ConstTensorPin cellToInputWeightsPin =
246 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
247 9,
248 model,
249 data,
250 g_DontPermute,
251 nullptr,
252 true);
253
254 // 10: The cell-to-forget weights: Optional. A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
255 const ConstTensorPin cellToForgetWeightsPin =
256 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
257 10,
258 model,
259 data,
260 g_DontPermute,
261 nullptr,
262 true);
263
264 // 11: The cell-to-output weights: Optional. A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
265 const ConstTensorPin cellToOutputWeightsPin =
266 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
267 11,
268 model,
269 data,
270 g_DontPermute,
271 nullptr,
272 true);
273
274 // 12: The input gate bias: Optional. A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [num_units].
275 const ConstTensorPin inputGateBiasPin =
276 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
277 12,
278 model,
279 data,
280 g_DontPermute,
281 nullptr,
282 true);
283
284 // 16: The projection weights: Optional. A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape
285 // [output_size, num_units].
286 const ConstTensorPin projectionWeightsPin =
287 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
288 16,
289 model,
290 data,
291 g_DontPermute,
292 nullptr,
293 true);
294
295 // 17: The projection bias: Optional. A 1-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [output_size].
296 const ConstTensorPin projectionBiasPin =
297 ConvertOperationInputToConstTensorPin<hal_1_0::HalPolicy>(operation,
298 17,
299 model,
300 data,
301 g_DontPermute,
302 nullptr,
303 true);
304
305 if ((!inputToInputWeightsPin.IsValid() && !inputToInputWeightsPin.IsOptional()) ||
306 (!recurrentToInputWeightsPin.IsValid() && !recurrentToInputWeightsPin.IsOptional()) ||
307 (!cellToInputWeightsPin.IsValid() && !cellToInputWeightsPin.IsOptional()) ||
308 (!cellToForgetWeightsPin.IsValid() && !cellToForgetWeightsPin.IsOptional()) ||
309 (!cellToOutputWeightsPin.IsValid() && !cellToOutputWeightsPin.IsOptional()) ||
310 (!inputGateBiasPin.IsValid() && !inputGateBiasPin.IsOptional()) ||
311 (!projectionWeightsPin.IsValid() && !projectionWeightsPin.IsOptional()) ||
312 (!projectionBiasPin.IsValid() && !projectionBiasPin.IsOptional()))
313 {
314 return Fail("%s: Operation has invalid tensor inputs", __func__);
315 }
316
317 // Get the mandatory input scalars (actually 1-D tensors of size 1):
318 // 20: The activation function: A value indicating the activation function:
319 // 0: None; 1: Relu; 3: Relu6; 4: Tanh; 6: Sigmoid.
320 // 21: The clipping threshold: for the cell state, such that values are bound within [-cell_clip, cell_clip].
321 // If set to 0.0 then clipping is disabled.
322 // 22: The clipping threshold: for the output from the projection layer, such that values are bound within
323 // [-proj_clip, proj_clip]. If set to 0.0 then clipping is disabled.
324 ActivationFn activation;
325 float cellClip;
326 float projClip;
327 if (!GetInputActivationFunctionFromTensor<hal_1_0::HalPolicy>(operation, 20, activation, model, data) ||
328 !GetInputScalar<hal_1_0::HalPolicy>(operation, 21, OperandType::FLOAT32, cellClip, model, data) ||
329 !GetInputScalar<hal_1_0::HalPolicy>(operation, 22, OperandType::FLOAT32, projClip, model, data))
330 {
331 return Fail("%s: Operation has invalid scalar inputs", __func__);
332 }
333
334 // Outputs:
335 // 00: The scratch buffer: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, num_units * 4]
336 // with CIFG, or [batch_size, num_units * 3] without CIFG.
337 const Operand* scratchBuffer = GetOutputOperand<hal_1_0::HalPolicy>(operation, 0, model);
338 if (!scratchBuffer)
339 {
340 return Fail("%s: Could not read output 0: scratchBuffer", __func__);
341 }
342 // 01: The output state (out): A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, output_size].
343 const Operand* outputStateOut = GetOutputOperand<hal_1_0::HalPolicy>(operation, 1, model);
344 if (!outputStateOut)
345 {
346 return Fail("%s: Could not read output 1: outputStateOut", __func__);
347 }
348 // 02: The cell state (out): A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, num_units].
349 const Operand* cellStateOut = GetOutputOperand<hal_1_0::HalPolicy>(operation, 2, model);
350 if (!cellStateOut)
351 {
352 return Fail("%s: Could not read output 2: cellStateOut", __func__);
353 }
354 // 03: The output: A 2-D tensor of ANEURALNETWORKS_TENSOR_FLOAT32, of shape [batch_size, output_size]. This is
355 // effectively the same as the current “output state (out)” value.
356 const Operand* output = GetOutputOperand<hal_1_0::HalPolicy>(operation, 3, model);
357 if (!output)
358 {
359 return Fail("%s: Could not read output 3: output", __func__);
360 }
361
362 // set the params structure for the AddLstmLayer call
363 armnn::LstmInputParams params;
364 params.m_InputToInputWeights = inputToInputWeightsPin.GetConstTensorPtr();
365 params.m_InputToForgetWeights = inputToForgetWeightsPin.GetConstTensorPtr();
366 params.m_InputToCellWeights = inputToCellWeightsPin.GetConstTensorPtr();
367 params.m_InputToOutputWeights = inputToOutputWeightsPin.GetConstTensorPtr();
368 params.m_RecurrentToInputWeights = recurrentToInputWeightsPin.GetConstTensorPtr();
369 params.m_RecurrentToForgetWeights = recurrentToForgetWeightsPin.GetConstTensorPtr();
370 params.m_RecurrentToCellWeights = recurrentToCellWeightsPin.GetConstTensorPtr();
371 params.m_RecurrentToOutputWeights = recurrentToOutputWeightsPin.GetConstTensorPtr();
372 params.m_CellToInputWeights = cellToInputWeightsPin.GetConstTensorPtr();
373 params.m_CellToForgetWeights = cellToForgetWeightsPin.GetConstTensorPtr();
374 params.m_CellToOutputWeights = cellToOutputWeightsPin.GetConstTensorPtr();
375 params.m_InputGateBias = inputGateBiasPin.GetConstTensorPtr();
376 params.m_ForgetGateBias = forgetGateBiasPin.GetConstTensorPtr();
377 params.m_CellBias = cellBiasPin.GetConstTensorPtr();
378 params.m_OutputGateBias = outputGateBiasPin.GetConstTensorPtr();
379 params.m_ProjectionWeights = projectionWeightsPin.GetConstTensorPtr();
380 params.m_ProjectionBias = projectionBiasPin.GetConstTensorPtr();
381
382 // set the layer descriptor
383 armnn::LstmDescriptor desc;
384 desc.m_ActivationFunc = activation;
385 desc.m_ClippingThresCell = cellClip;
386 desc.m_ClippingThresProj = projClip;
387 desc.m_CifgEnabled = (params.m_InputToInputWeights == nullptr ||
388 params.m_RecurrentToInputWeights == nullptr ||
389 params.m_InputGateBias == nullptr);
390 desc.m_PeepholeEnabled = (params.m_CellToForgetWeights != nullptr ||
391 params.m_CellToOutputWeights != nullptr);
392 desc.m_ProjectionEnabled = (params.m_ProjectionWeights != nullptr);
393
394 // validate the optional input groups
395 if (desc.m_CifgEnabled &&
396 (params.m_InputToInputWeights != nullptr ||
397 params.m_RecurrentToInputWeights != nullptr ||
398 params.m_InputGateBias != nullptr))
399 {
400 return Fail("%s: All, or none, of input-to-input weights, recurrent-to-input weights,"
401 " and input gate bias must be provided", __func__);
402 }
403
404 if (!desc.m_ProjectionEnabled && params.m_ProjectionBias != nullptr)
405 {
406 return Fail("%s: projection bias should not be provided without projection weights", __func__);
407 }
408
409 if (desc.m_PeepholeEnabled &&
410 (params.m_CellToForgetWeights == nullptr ||
411 params.m_CellToOutputWeights == nullptr ||
412 (!desc.m_CifgEnabled && params.m_CellToInputWeights == nullptr)))
413 {
414 return Fail("%s: All, or none, of cell-to-forget weights and cell-to-output weights must be provided"
415 " and, if CIFG is not enabled, cell-to-input weights must also be provided", __func__);
416 }
417
418 // Check if the layer is supported
419 // Inputs
420 const armnn::TensorInfo& inputInfo = input.GetTensorInfo();
421 const armnn::TensorInfo& outputStateInInfo = outputStateIn.GetTensorInfo();
422 const armnn::TensorInfo& cellStateInInfo = cellStateIn.GetTensorInfo();
423
424 // Outputs
425 const armnn::TensorInfo& scratchBufferInfo = GetTensorInfoForOperand(*scratchBuffer);
426 const armnn::TensorInfo& outputStateOutInfo = GetTensorInfoForOperand(*outputStateOut);
427 const armnn::TensorInfo& cellStateOutInfo = GetTensorInfoForOperand(*cellStateOut);
428 const armnn::TensorInfo& outputInfo = GetTensorInfoForOperand(*output);
429
430 // Basic parameters
431 armnn::LstmInputParamsInfo paramsInfo;
432 paramsInfo.m_InputToForgetWeights = &(params.m_InputToForgetWeights->GetInfo());
433 paramsInfo.m_InputToCellWeights = &(params.m_InputToCellWeights->GetInfo());
434 paramsInfo.m_InputToOutputWeights = &(params.m_InputToOutputWeights->GetInfo());
435 paramsInfo.m_RecurrentToForgetWeights = &(params.m_RecurrentToForgetWeights->GetInfo());
436 paramsInfo.m_RecurrentToCellWeights = &(params.m_RecurrentToCellWeights->GetInfo());
437 paramsInfo.m_RecurrentToOutputWeights = &(params.m_RecurrentToOutputWeights->GetInfo());
438 paramsInfo.m_ForgetGateBias = &(params.m_ForgetGateBias->GetInfo());
439 paramsInfo.m_CellBias = &(params.m_CellBias->GetInfo());
440 paramsInfo.m_OutputGateBias = &(params.m_OutputGateBias->GetInfo());
441
442 // Optional parameters
443 if(!desc.m_CifgEnabled)
444 {
445 paramsInfo.m_InputToInputWeights = &(params.m_InputToInputWeights->GetInfo());
446 paramsInfo.m_RecurrentToInputWeights = &(params.m_RecurrentToInputWeights->GetInfo());
447 if (params.m_CellToInputWeights != nullptr)
448 {
449 paramsInfo.m_CellToInputWeights = &(params.m_CellToInputWeights->GetInfo());
450 }
451 paramsInfo.m_InputGateBias = &(params.m_InputGateBias->GetInfo());
452 }
453
454 if(desc.m_ProjectionEnabled)
455 {
456 paramsInfo.m_ProjectionWeights = &(params.m_ProjectionWeights->GetInfo());
457 if (params.m_ProjectionBias != nullptr)
458 {
459 paramsInfo.m_ProjectionBias = &(params.m_ProjectionBias->GetInfo());
460 }
461 }
462
463 if(desc.m_PeepholeEnabled)
464 {
465 paramsInfo.m_CellToForgetWeights = &(params.m_CellToForgetWeights->GetInfo());
466 paramsInfo.m_CellToOutputWeights = &(params.m_CellToOutputWeights->GetInfo());
467 }
468
469 bool isSupported = false;
470 armnn::BackendId setBackend;
471 FORWARD_LAYER_SUPPORT_FUNC(__func__,
472 IsLstmSupported,
473 data.m_Backends,
474 isSupported,
475 setBackend,
476 inputInfo,
477 outputStateInInfo,
478 cellStateInInfo,
479 scratchBufferInfo,
480 outputStateOutInfo,
481 cellStateOutInfo,
482 outputInfo,
483 desc,
484 paramsInfo);
485 if (!isSupported)
486 {
487 return false;
488 }
489
490 // Add the layer
491 armnn::IConnectableLayer* layer = data.m_Network->AddLstmLayer(desc, params, "Lstm");
492 layer->SetBackendId(setBackend);
493
494 input.Connect(layer->GetInputSlot(0));
495 outputStateIn.Connect(layer->GetInputSlot(1));
496 cellStateIn.Connect(layer->GetInputSlot(2));
497
498 return (SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 0, *layer, 0, model, data) &&
499 SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 1, *layer, 1, model, data) &&
500 SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 2, *layer, 2, model, data) &&
501 SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 3, *layer, 3, model, data));
502 }
503
ConvertL2Normalization(const Operation & operation,const Model & model,ConversionData & data)504 bool HalPolicy::ConvertL2Normalization(const Operation& operation, const Model& model, ConversionData& data)
505 {
506 ALOGV("hal_1_0::HalPolicy::ConvertL2Normalization()");
507 return ::ConvertL2Normalization<hal_1_0::HalPolicy>(operation, model, data);
508 }
509
ConvertL2Pool2d(const Operation & operation,const Model & model,ConversionData & data)510 bool HalPolicy::ConvertL2Pool2d(const Operation& operation, const Model& model, ConversionData& data)
511 {
512 ALOGV("hal_1_0::HalPolicy::ConvertL2Pool2d()");
513 return ConvertPooling2d<hal_1_0::HalPolicy>(operation, __func__, armnn::PoolingAlgorithm::L2, model, data);
514 }
515
ConvertMaxPool2d(const Operation & operation,const Model & model,ConversionData & data)516 bool HalPolicy::ConvertMaxPool2d(const Operation& operation, const Model& model, ConversionData& data)
517 {
518 ALOGV("hal_1_0::HalPolicy::ConvertMaxPool2d()");
519 return ConvertPooling2d<hal_1_0::HalPolicy>(operation, __func__, armnn::PoolingAlgorithm::Max, model, data);
520 }
521
ConvertReLu(const Operation & operation,const Model & model,ConversionData & data)522 bool HalPolicy::ConvertReLu(const Operation& operation, const Model& model, ConversionData& data)
523 {
524 ALOGV("hal_1_0::HalPolicy::ConvertReLu()");
525 return ::ConvertReLu<hal_1_0::HalPolicy>(operation, model, data);
526 }
527
ConvertReLu1(const Operation & operation,const Model & model,ConversionData & data)528 bool HalPolicy::ConvertReLu1(const Operation& operation, const Model& model, ConversionData& data)
529 {
530 ALOGV("hal_1_0::HalPolicy::ConvertReLu1()");
531 return ::ConvertReLu1<hal_1_0::HalPolicy>(operation, model, data);
532 }
533
ConvertReLu6(const Operation & operation,const Model & model,ConversionData & data)534 bool HalPolicy::ConvertReLu6(const Operation& operation, const Model& model, ConversionData& data)
535 {
536 ALOGV("hal_1_0::HalPolicy::ConvertReLu6()");
537 return ::ConvertReLu6<hal_1_0::HalPolicy>(operation, model, data);
538 }
539
ConvertSoftmax(const Operation & operation,const Model & model,ConversionData & data)540 bool HalPolicy::ConvertSoftmax(const Operation& operation, const Model& model, ConversionData& data)
541 {
542 ALOGV("hal_1_0::HalPolicy::ConvertSoftmax()");
543
544 LayerInputHandle input = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 0, model, data);
545 if (!input.IsValid())
546 {
547 return Fail("%s: Operation has invalid inputs", __func__);
548 }
549
550 const Operand* outputOperand = GetOutputOperand<hal_1_0::HalPolicy>(operation, 0, model);
551 if (!outputOperand)
552 {
553 return Fail("%s: Operation has no outputs", __func__);
554 }
555
556 const armnn::TensorInfo& outputInfo = GetTensorInfoForOperand(*outputOperand);
557 if (IsDynamicTensor(outputInfo))
558 {
559 return Fail("%s: Dynamic output tensors are not supported", __func__);
560 }
561
562 armnn::SoftmaxDescriptor desc;
563 if (!GetInputFloat32<hal_1_0::HalPolicy>(operation, 1, desc.m_Beta, model, data))
564 {
565 return Fail("%s: Operation has invalid inputs", __func__);
566 }
567
568 bool isSupported = false;
569 armnn::BackendId setBackend;
570 FORWARD_LAYER_SUPPORT_FUNC(__func__,
571 IsSoftmaxSupported,
572 data.m_Backends,
573 isSupported,
574 setBackend,
575 input.GetTensorInfo(),
576 outputInfo,
577 desc);
578 if (!isSupported)
579 {
580 return false;
581 }
582
583 armnn::IConnectableLayer* layer = data.m_Network->AddSoftmaxLayer(desc);
584 layer->SetBackendId(setBackend);
585 if (!layer)
586 {
587 return Fail("%s: Could not add the SoftmaxLayer", __func__);
588 }
589 input.Connect(layer->GetInputSlot(0));
590
591 return SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 0, *layer, model, data);
592 }
593
ConvertSpaceToDepth(const Operation & operation,const Model & model,ConversionData & data)594 bool HalPolicy::ConvertSpaceToDepth(const Operation& operation, const Model& model, ConversionData& data)
595 {
596 ALOGV("hal_1_0::HalPolicy::ConvertSpaceToDepth()");
597
598 LayerInputHandle input = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 0, model, data);
599 if (!input.IsValid() )
600 {
601 return Fail("%s: Operation has invalid inputs", __func__);
602 }
603
604 const armnn::TensorInfo& inputInfo = input.GetTensorInfo();
605 unsigned int rank = inputInfo.GetNumDimensions();
606
607 if (rank != 4)
608 {
609 return Fail("%s: Only inputs with rank 4 are supported", __func__);
610 }
611
612 armnn::SpaceToDepthDescriptor desc;
613
614 GetInputScalar<hal_1_0::HalPolicy>(operation, 1, OperandType::INT32, desc.m_BlockSize, model, data);
615
616 if (desc.m_BlockSize <= 1)
617 {
618 return Fail("%s: Block size must be at least 1 in all dimensions");
619 }
620
621 const Operand* output = GetOutputOperand<hal_1_0::HalPolicy>(operation, 0, model);
622 if (!output)
623 {
624 return Fail("%s: Could not read output 0", __func__);
625 }
626
627 const armnn::TensorInfo& outputInfo = GetTensorInfoForOperand(*output);
628 if (IsDynamicTensor(outputInfo))
629 {
630 return Fail("%s: Dynamic output tensors are not supported", __func__);
631 }
632
633 bool isSupported = false;
634 armnn::BackendId setBackend;
635 FORWARD_LAYER_SUPPORT_FUNC(__func__,
636 IsSpaceToDepthSupported,
637 data.m_Backends,
638 isSupported,
639 setBackend,
640 inputInfo,
641 outputInfo,
642 desc);
643 if (!isSupported)
644 {
645 return false;
646 }
647
648 armnn::IConnectableLayer* const layer = data.m_Network->AddSpaceToDepthLayer(desc);
649 layer->SetBackendId(setBackend);
650 if (!layer)
651 {
652 return Fail("%s: Could not add the SpaceToDepthLayer", __func__);
653 }
654 input.Connect(layer->GetInputSlot(0));
655
656 return SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 0, *layer, model, data);
657 }
658
ConvertTanH(const Operation & operation,const Model & model,ConversionData & data)659 bool HalPolicy::ConvertTanH(const Operation& operation, const Model& model, ConversionData& data)
660 {
661 ALOGV("hal_1_0::HalPolicy::ConvertTanH()");
662 return ::ConvertTanH<hal_1_0::HalPolicy>(operation, model, data);
663 }
664
ConvertReshape(const Operation & operation,const Model & model,ConversionData & data)665 bool HalPolicy::ConvertReshape(const Operation& operation, const Model& model, ConversionData& data)
666 {
667 ALOGV("hal_1_0::HalPolicy::ConvertReshape()");
668 return ::ConvertReshape<hal_1_0::HalPolicy>(operation, model, data);
669 }
670
ConvertResizeBilinear(const Operation & operation,const Model & model,ConversionData & data)671 bool HalPolicy::ConvertResizeBilinear(const Operation& operation, const Model& model, ConversionData& data)
672 {
673 ALOGV("hal_1_0::HalPolicy::ConvertResizeBilinear()");
674
675 LayerInputHandle input = ConvertToLayerInputHandle<hal_1_0::HalPolicy>(operation, 0, model, data);
676 if (!input.IsValid())
677 {
678 return Fail("%s: Could not read input 0", __func__);
679 }
680
681 const Operand* output = GetOutputOperand<hal_1_0::HalPolicy>(operation, 0, model);
682 if (!output)
683 {
684 return Fail("%s: Could not read output 0", __func__);
685 }
686
687 const armnn::TensorInfo& inputInfo = input.GetTensorInfo();
688 const armnn::TensorInfo& outputInfo = GetTensorInfoForOperand(*output);
689
690 if (IsDynamicTensor(outputInfo))
691 {
692 return Fail("%s: Dynamic output tensors are not supported", __func__);
693 }
694
695 armnn::ResizeDescriptor desc;
696 desc.m_Method = armnn::ResizeMethod::Bilinear;
697 desc.m_DataLayout = armnn::DataLayout::NHWC;
698
699 bool isSupported = false;
700 armnn::BackendId setBackend;
701 FORWARD_LAYER_SUPPORT_FUNC(__func__,
702 IsResizeSupported,
703 data.m_Backends,
704 isSupported,
705 setBackend,
706 inputInfo,
707 outputInfo,
708 desc);
709 if (!isSupported)
710 {
711 return false;
712 }
713
714 if (!GetInputScalar<hal_1_0::HalPolicy>(operation, 1, OperandType::INT32, desc.m_TargetWidth, model, data) ||
715 !GetInputScalar<hal_1_0::HalPolicy>(operation, 2, OperandType::INT32, desc.m_TargetHeight, model, data))
716 {
717 return Fail("%s: Operation has invalid inputs", __func__);
718 }
719
720 armnn::IConnectableLayer* layer = data.m_Network->AddResizeLayer(desc);
721 layer->SetBackendId(setBackend);
722 if (!layer)
723 {
724 return Fail("%s: Could not add the ResizeLayer", __func__);
725 }
726 layer->GetOutputSlot(0).SetTensorInfo(outputInfo);
727 input.Connect(layer->GetInputSlot(0));
728
729 return SetupAndTrackLayerOutputSlot<hal_1_0::HalPolicy>(operation, 0, *layer, model, data);
730
731 }
732
733 } // namespace hal_1_0
734 } // namespace armnn_driver
735