ArmNN
 24.02
RefLayerSupport.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 "RefLayerSupport.hpp"
7 
8 #include <armnn/TypesUtils.hpp>
9 #include <armnn/Types.hpp>
10 #include <armnn/utility/IgnoreUnused.hpp>
11 #include <armnn/utility/NumericCast.hpp>
12 #include <armnn/utility/PolymorphicDowncast.hpp>
13 
14 #include <LayerSupportCommon.hpp>
15 #include <backendsCommon/LayerSupportRules.hpp>
16 
17 #include <vector>
18 #include <array>
19 
20 namespace armnn
21 {
22 
23 namespace
24 {
25 
26 template<typename Float32Func, typename Uint8Func, typename ... Params>
27 bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
28  DataType dataType,
29  Float32Func floatFuncPtr,
30  Uint8Func uint8FuncPtr,
31  Params&&... params)
32 {
33  return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
34  dataType,
35  &FalseFunc<Params...>,
36  floatFuncPtr,
37  uint8FuncPtr,
38  &FalseFunc<Params...>,
39  &FalseFunc<Params...>,
40  std::forward<Params>(params)...);
41 }
42 
43 } // anonymous namespace
44 
45 namespace
46 {
47 
48 std::string CreateIncorrectDimensionsErrorMsg(unsigned int expected,
49  unsigned int actual,
50  std::string& layerStr,
51  std::string& tensorName)
52 {
53  std::string errorMsg = "Reference " + layerStr + ": Expected " + std::to_string(expected) + " dimensions but got" +
54  " " + std::to_string(actual) + " dimensions instead, for the '" + tensorName + "' tensor.";
55 
56  return errorMsg;
57 }
58 
59 } // anonymous namespace
60 
61 bool RefLayerSupport::IsLayerSupported(const LayerType& type,
62  const std::vector<TensorInfo>& infos,
63  const BaseDescriptor& descriptor,
64  const Optional<LstmInputParamsInfo>& lstmParamsInfo,
65  const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmInputParamsInfo,
66  Optional<std::string&> reasonIfUnsupported) const
67 {
68  switch (type)
69  {
70  case LayerType::Activation:
71  return IsActivationSupported(infos[0],
72  infos[1],
73  *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
74  reasonIfUnsupported);
75  case LayerType::Addition:
76  return IsAdditionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
77  case LayerType::ArgMinMax:
78  return IsArgMinMaxSupported(infos[0],
79  infos[1],
80  *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
81  reasonIfUnsupported);
82  case LayerType::BatchMatMul:
83  return IsBatchMatMulSupported(infos[0],
84  infos[1],
85  infos[2],
86  *(PolymorphicDowncast<const BatchMatMulDescriptor*>(&descriptor)),
87  reasonIfUnsupported);
88  case LayerType::BatchNormalization:
89  return IsBatchNormalizationSupported(infos[0],
90  infos[1],
91  infos[2],
92  infos[3],
93  infos[4],
94  infos[5],
95  *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
96  (&descriptor)),
97  reasonIfUnsupported);
98  case LayerType::BatchToSpaceNd:
99  return IsBatchToSpaceNdSupported(infos[0],
100  infos[1],
101  *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
102  reasonIfUnsupported);
103  case LayerType::BroadcastTo:
104  return IsBroadcastToSupported(infos[0],
105  infos[1],
106  *(PolymorphicDowncast<const BroadcastToDescriptor*>(&descriptor)),
107  reasonIfUnsupported);
108  case LayerType::Comparison:
109  return IsComparisonSupported(infos[0],
110  infos[1],
111  infos[2],
112  *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
113  reasonIfUnsupported);
114  case LayerType::Concat:
115  {
116  std::vector<const TensorInfo*> inputInfos;
117  for (uint32_t i = 0; i < (infos.size() - 1); i++)
118  {
119  inputInfos.push_back(&infos[i]);
120  }
121  return IsConcatSupported(inputInfos,
122  infos[infos.size() - 1],
123  *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
124  reasonIfUnsupported);
125  }
126  case LayerType::Constant:
127  return IsConstantSupported(infos[0], reasonIfUnsupported);
128  case LayerType::ConvertFp16ToFp32:
129  return IsConvertFp16ToFp32Supported(infos[0], infos[1], reasonIfUnsupported);
130  case LayerType::ConvertFp32ToFp16:
131  return IsConvertFp32ToFp16Supported(infos[0], infos[1], reasonIfUnsupported);
132  case LayerType::Convolution2d:
133  {
134  if (infos.size() != 4)
135  {
136  throw InvalidArgumentException("Invalid number of Convolution2d TensorInfos. "
137  "TensorInfos should be of format: {input, output, weights, biases}.");
138  }
139 
140  auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
141  if (infos[3] == TensorInfo())
142  {
143  return IsConvolution2dSupported(infos[0],
144  infos[1],
145  desc,
146  infos[2],
147  EmptyOptional(),
148  reasonIfUnsupported);
149  }
150  else
151  {
152  return IsConvolution2dSupported(infos[0],
153  infos[1],
154  desc,
155  infos[2],
156  infos[3],
157  reasonIfUnsupported);
158  }
159  }
160  case LayerType::DepthToSpace:
161  return IsDepthToSpaceSupported(infos[0],
162  infos[1],
163  *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
164  reasonIfUnsupported);
165  case LayerType::DepthwiseConvolution2d:
166  {
167  if (infos.size() != 4)
168  {
169  throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d TensorInfos. "
170  "TensorInfos should be of format: {input, output, weights, biases}.");
171  }
172 
173  auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
174  if (infos[3] == TensorInfo())
175  {
176  return IsDepthwiseConvolutionSupported(infos[0],
177  infos[1],
178  desc,
179  infos[2],
180  EmptyOptional(),
181  reasonIfUnsupported);
182  }
183  else
184  {
185  return IsDepthwiseConvolutionSupported(infos[0],
186  infos[1],
187  desc,
188  infos[2],
189  infos[3],
190  reasonIfUnsupported);
191  }
192  }
193  case LayerType::Dequantize:
194  return IsDequantizeSupported(infos[0], infos[1], reasonIfUnsupported);
195  case LayerType::Division:
196  return IsDivisionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
197  case LayerType::ElementwiseBinary:
198  {
199  std::array<DataType, 7> supportedTypes =
200  {
201  DataType::Float32,
202  DataType::Float16,
203  DataType::QAsymmS8,
204  DataType::QAsymmU8,
205  DataType::QSymmS16,
206  DataType::Signed32
207  };
208 
209  bool supported = true;
210  supported &= CheckSupportRule(TypeAnyOf(infos[0], supportedTypes), reasonIfUnsupported,
211  "Reference elementwise unary: input type not supported");
212 
213  supported &= CheckSupportRule(TypeAnyOf(infos[1], supportedTypes), reasonIfUnsupported,
214  "Reference elementwise unary: input type not supported");
215 
216  supported &= CheckSupportRule(TypeAnyOf(infos[2], supportedTypes), reasonIfUnsupported,
217  "Reference elementwise unary: output type not supported");
218 
219  supported &= CheckSupportRule(TypesAreEqual(infos[0], infos[1]), reasonIfUnsupported,
220  "Reference elementwise unary: input types not matching");
221 
222  supported &= CheckSupportRule(TypesAreEqual(infos[0], infos[2]), reasonIfUnsupported,
223  "Reference elementwise unary: input and output types not matching");
224 
225  return supported;
226  }
227  case LayerType::ElementwiseUnary:
228  return IsElementwiseUnarySupported(infos[0],
229  infos[1],
230  *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor)),
231  reasonIfUnsupported);
232  case LayerType::Fill:
233  return IsFillSupported(infos[0],
234  infos[1],
235  *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
236  reasonIfUnsupported);
237  case LayerType::Floor:
238  return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
239  case LayerType::FullyConnected:
240  return IsFullyConnectedSupported(infos[0],
241  infos[1],
242  infos[2],
243  infos[3],
244  *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
245  reasonIfUnsupported);
246  case LayerType::Gather:
247  return IsGatherSupported(infos[0],
248  infos[1],
249  infos[2],
250  *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
251  reasonIfUnsupported);
252  case LayerType::GatherNd:
253  return IsGatherNdSupported(infos[0],
254  infos[1],
255  infos[2],
256  reasonIfUnsupported);
257  case LayerType::Input:
258  return IsInputSupported(infos[0], reasonIfUnsupported);
259  case LayerType::InstanceNormalization:
260  return IsInstanceNormalizationSupported(infos[0],
261  infos[1],
262  *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
263  (&descriptor)),
264  reasonIfUnsupported);
265  case LayerType::L2Normalization:
266  return IsL2NormalizationSupported(infos[0],
267  infos[1],
268  *(PolymorphicDowncast<const L2NormalizationDescriptor*>(&descriptor)),
269  reasonIfUnsupported);
270  case LayerType::LogicalBinary:
271  return IsLogicalBinarySupported(infos[0],
272  infos[1],
273  infos[2],
274  *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
275  reasonIfUnsupported);
276  case LayerType::LogSoftmax:
277  return IsLogSoftmaxSupported(infos[0],
278  infos[1],
279  *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
280  reasonIfUnsupported);
281  case LayerType::Lstm:
282  return IsLstmSupported(infos[0],
283  infos[1],
284  infos[2],
285  infos[3],
286  infos[4],
287  infos[5],
288  infos[6],
289  *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
290  lstmParamsInfo.value(),
291  reasonIfUnsupported);
292  case LayerType::QLstm:
293  return IsQLstmSupported(infos[0],
294  infos[1],
295  infos[2],
296  infos[3],
297  infos[4],
298  infos[5],
299  *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
300  lstmParamsInfo.value(),
301  reasonIfUnsupported);
302  case LayerType::Maximum:
303  return IsMaximumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
304  case LayerType::Mean:
305  return IsMeanSupported(infos[0],
306  infos[1],
307  *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
308  reasonIfUnsupported);
309  case LayerType::Minimum:
310  return IsMinimumSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
311  case LayerType::Multiplication:
312  return IsMultiplicationSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
313  case LayerType::Normalization:
314  return IsNormalizationSupported(infos[0],
315  infos[1],
316  *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
317  reasonIfUnsupported);
318  case LayerType::Output:
319  return IsOutputSupported(infos[0], reasonIfUnsupported);
320  case LayerType::Pad:
321  return IsPadSupported(infos[0],
322  infos[1],
323  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
324  reasonIfUnsupported);
325  case LayerType::Permute:
326  return IsPermuteSupported(infos[0],
327  infos[1],
328  *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
329  reasonIfUnsupported);
330  case LayerType::Pooling2d:
331  return IsPooling2dSupported(infos[0],
332  infos[1],
333  *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
334  reasonIfUnsupported);
335  case LayerType::Prelu:
336  return IsPreluSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
337  case LayerType::Quantize:
338  return IsQuantizeSupported(infos[0], infos[1], reasonIfUnsupported);
339  case LayerType::Reshape:
340  return IsReshapeSupported(infos[0],
341  infos[1],
342  *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
343  reasonIfUnsupported);
344  case LayerType::Resize:
345  return IsResizeSupported(infos[0],
346  infos[1],
347  *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
348  reasonIfUnsupported);
349  case LayerType::ReverseV2:
350  return IsReverseV2Supported(infos[0],
351  infos[1],
352  infos[2],
353  reasonIfUnsupported);
354  case LayerType::Reduce:
355  return IsReduceSupported(infos[0],
356  infos[1],
357  *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
358  reasonIfUnsupported);
359  case LayerType::Slice:
360  return IsSliceSupported(infos[0],
361  infos[1],
362  *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
363  reasonIfUnsupported);
364  case LayerType::Softmax:
365  return IsSoftmaxSupported(infos[0],
366  infos[1],
367  *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
368  reasonIfUnsupported);
369  case LayerType::SpaceToBatchNd:
370  return IsSpaceToBatchNdSupported(infos[0],
371  infos[1],
372  *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
373  reasonIfUnsupported);
374  case LayerType::SpaceToDepth:
375  return IsSpaceToDepthSupported(infos[0],
376  infos[1],
377  *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
378  reasonIfUnsupported);
379  case LayerType::Splitter:
380  {
381  std::vector<TensorInfo> outputInfos;
382  for (uint32_t i = 1; i < infos.size(); i++)
383  {
384  outputInfos.push_back(infos[i]);
385  }
386  return IsSplitterSupported(infos[0],
387  {outputInfos.begin(), outputInfos.end()},
388  *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
389  reasonIfUnsupported);
390  }
391  case LayerType::Stack:
392  {
393  std::vector<const TensorInfo*> inputInfos;
394  for (uint32_t i = 0; i < infos.size() - 1; i++)
395  {
396  inputInfos.push_back(&infos[i]);
397  }
398  return IsStackSupported(inputInfos,
399  infos[infos.size() - 1],
400  *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
401  reasonIfUnsupported);
402  }
403  case LayerType::StridedSlice:
404  return IsStridedSliceSupported(infos[0],
405  infos[1],
406  *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
407  reasonIfUnsupported);
408  case LayerType::Subtraction:
409  return IsSubtractionSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
410  case LayerType::Tile:
411  return IsTileSupported(infos[0],
412  infos[1],
413  *(PolymorphicDowncast<const TileDescriptor*>(&descriptor)),
414  reasonIfUnsupported);
415  case LayerType::Transpose:
416  return IsTransposeSupported(infos[0],
417  infos[1],
418  *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
419  reasonIfUnsupported);
420  case LayerType::TransposeConvolution2d:
421  {
422  if (infos.size() != 4)
423  {
424  throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. "
425  "TensorInfos should be of format: {input, output, weights, biases}.");
426  }
427 
428  auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
429  if (infos[3] == TensorInfo())
430  {
431  return IsTransposeConvolution2dSupported(infos[0],
432  infos[1],
433  desc,
434  infos[2],
435  EmptyOptional(),
436  reasonIfUnsupported);
437  }
438  else
439  {
440  return IsTransposeConvolution2dSupported(infos[0],
441  infos[1],
442  desc,
443  infos[2],
444  infos[3],
445  reasonIfUnsupported);
446  }
447  }
448  case LayerType::Cast:
449  return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
450  case LayerType::ChannelShuffle:
451  return IsChannelShuffleSupported(infos[0],
452  infos[1],
453  *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
454  reasonIfUnsupported);
455  case LayerType::Convolution3d:
456  {
457  if (infos.size() != 4)
458  {
459  throw InvalidArgumentException("Invalid number of Convolution3d TensorInfos. "
460  "TensorInfos should be of format: {input, output, weights, biases}.");
461  }
462 
463  auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
464  if (infos[3] == TensorInfo())
465  {
466  return IsConvolution3dSupported(infos[0],
467  infos[1],
468  desc,
469  infos[2],
470  EmptyOptional(),
471  reasonIfUnsupported);
472  }
473  else
474  {
475  return IsConvolution3dSupported(infos[0],
476  infos[1],
477  desc,
478  infos[2],
479  infos[3],
480  reasonIfUnsupported);
481  }
482  }
483  case LayerType::Debug:
484  return IsDebugSupported(infos[0], infos[1], reasonIfUnsupported);
485  case LayerType::DetectionPostProcess:
486  return IsDetectionPostProcessSupported(infos[0],
487  infos[1],
488  infos[2],
489  infos[3],
490  infos[4],
491  infos[5],
492  infos[6],
493  *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
494  (&descriptor)),
495  reasonIfUnsupported);
496  case LayerType::FakeQuantization:
497  return IsFakeQuantizationSupported(infos[0],
498  *(PolymorphicDowncast<const FakeQuantizationDescriptor*>(&descriptor)),
499  reasonIfUnsupported);
500  case LayerType::MemCopy:
501  return IsMemCopySupported(infos[0], infos[1], reasonIfUnsupported);
502  case LayerType::Rank:
503  return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
504  case LayerType::Shape:
505  return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
506  case LayerType::UnidirectionalSequenceLstm:
507  {
508  if (infos.size() != 6)
509  {
510  throw InvalidArgumentException("Invalid number of UnidirectionalSequenceLstm TensorInfos. TensorInfos "
511  "should be of format: {input, outputStateIn, cellStateIn, "
512  "hiddenStateOutputVal, cellStateOutputVal, output}");
513  }
514  auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
515  return IsUnidirectionalSequenceLstmSupported(infos[0],
516  infos[1],
517  infos[2],
518  infos[3],
519  infos[4],
520  infos[5],
521  desc,
522  lstmParamsInfo.value(),
523  reasonIfUnsupported);
524  }
525  case LayerType::Pooling3d:
526  return IsPooling3dSupported(infos[0],
527  infos[1],
528  *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
529  reasonIfUnsupported);
530  case LayerType::Map:
531  return true;
532  case LayerType::Unmap:
533  return true;
534  case LayerType::MemImport:
535  return LayerSupportBase::IsMemImportSupported(infos[0], infos[1], reasonIfUnsupported);
536  case LayerType::Merge:
537  return LayerSupportBase::IsMergeSupported(infos[0], infos[1], infos[2], reasonIfUnsupported);
538  case LayerType::QuantizedLstm:
539  return LayerSupportBase::IsQuantizedLstmSupported(infos[0],
540  infos[1],
541  infos[2],
542  infos[3],
543  infos[4],
544  quantizedLstmInputParamsInfo.value(),
545  reasonIfUnsupported);
546  default:
547  // layers not supported in reference by default:
548  // precompiled, standin, switch, fused
549  return false;
550  }
551 }
552 
553 bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
554  const TensorInfo& output,
555  const ActivationDescriptor& descriptor,
556  Optional<std::string&> reasonIfUnsupported) const
557 {
558  bool supported = true;
559 
560  // Define supported types.
561  std::array<DataType,6> supportedTypes = {
562  DataType::Float32,
563  DataType::Float16,
564  DataType::QAsymmS8,
565  DataType::QAsymmU8,
566  DataType::QSymmS16
567  };
568 
569  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
570  "Reference activation: input type not supported.");
571 
572  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
573  "Reference activation: output type not supported.");
574 
575  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
576  "Reference activation: input and output types mismatched.");
577 
578  supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
579  "Reference activation: input and output shapes are of different rank.");
580 
581 
582  struct ActivationFunctionSupported : public Rule
583  {
584  ActivationFunctionSupported(const ActivationDescriptor& desc)
585  {
586  switch(desc.m_Function)
587  {
588  case ActivationFunction::Abs:
589  case ActivationFunction::BoundedReLu:
590  case ActivationFunction::Elu:
591  case ActivationFunction::Gelu:
592  case ActivationFunction::HardSwish:
593  case ActivationFunction::LeakyReLu:
594  case ActivationFunction::Linear:
595  case ActivationFunction::ReLu:
596  case ActivationFunction::Sigmoid:
597  case ActivationFunction::SoftReLu:
598  case ActivationFunction::Sqrt:
599  case ActivationFunction::Square:
600  case ActivationFunction::TanH:
601  {
602  m_Res = true;
603  break;
604  }
605  default:
606  {
607  m_Res = false;
608  break;
609  }
610  }
611  }
612  };
613 
614  // Function is supported
615  supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
616  "Reference activation: function not supported.");
617 
618  return supported;
619 }
620 
621 bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
622  const TensorInfo& input1,
623  const TensorInfo& output,
624  Optional<std::string&> reasonIfUnsupported) const
625 {
626  bool supported = true;
627 
628  std::array<DataType,7> supportedTypes = {
629  DataType::Float32,
630  DataType::Float16,
631  DataType::QAsymmS8,
632  DataType::QAsymmU8,
633  DataType::QSymmS16,
634  DataType::Signed32
635  };
636 
637  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
638  "Reference addition: input 0 is not a supported type.");
639 
640  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
641  "Reference addition: input 1 is not a supported type.");
642 
643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
644  "Reference addition: output is not a supported type.");
645 
646  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
647  "Reference addition: input 0 and Input 1 types are mismatched");
648 
649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
650  "Reference addition: input and output types are mismatched");
651 
652  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
653  "Reference addition: shapes are not suitable for implicit broadcast.");
654 
655  return supported;
656 }
657 
658 bool RefLayerSupport::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output,
659  const armnn::ArgMinMaxDescriptor &descriptor,
660  armnn::Optional<std::string &> reasonIfUnsupported) const
661 {
662  IgnoreUnused(descriptor);
663 
664  std::array<DataType, 8> supportedInputTypes =
665  {
666  DataType::Float16,
667  DataType::Float32,
668  DataType::QAsymmS8,
669  DataType::QAsymmU8,
670  DataType::QSymmS16,
671  DataType::Signed32,
672  DataType::Signed64
673  };
674 
675  std::array<DataType,2> supportedOutputTypes = {
676  DataType::Signed32,
677  DataType::Signed64
678  };
679 
680  bool supported = true;
681 
682  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
683  "Reference ArgMinMax: input is not a supported type.");
684  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
685  "Reference ArgMinMax: output type not supported");
686 
687  return supported;
688 }
689 
690 bool RefLayerSupport::IsBatchMatMulSupported(const TensorInfo& inputX,
691  const TensorInfo& inputY,
692  const TensorInfo& output,
693  const BatchMatMulDescriptor& descriptor,
694  Optional<std::string &> reasonIfUnsupported) const
695 {
696  IgnoreUnused(descriptor);
697 
698  std::array<DataType, 6> supportedTypes =
699  {
700  DataType::Float16,
701  DataType::Float32,
702  DataType::QAsymmS8,
703  DataType::QAsymmU8,
704  DataType::QSymmS16
705  };
706 
707  bool supported = true;
708 
709  supported &= CheckSupportRule(TypeAnyOf(inputX, supportedTypes), reasonIfUnsupported,
710  "Reference batch matrix multiplication: input X is not a supported type");
711 
712  supported &= CheckSupportRule(TypeAnyOf(inputY, supportedTypes), reasonIfUnsupported,
713  "Reference batch matrix multiplication: input Y is not a supported type");
714 
715  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
716  "Reference batch matrix multiplication: output is not a supported type");
717 
718  supported &= CheckSupportRule(TypesAreEqual(inputX, inputY), reasonIfUnsupported,
719  "Reference batch matrix multiplication: input X and input Y types are mismatched");
720 
721  supported &= CheckSupportRule(TypesAreEqual(inputX, output), reasonIfUnsupported,
722  "Reference batch matrix multiplication: inputs and output types are mismatched");
723 
724  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputX, 2),
725  reasonIfUnsupported,
726  "Reference batch matrix multiplication: input X is not of rank 2 or greater");
727 
728  supported &= CheckSupportRule(TensorNumDimensionsAreGreaterOrEqualTo(inputY, 2),
729  reasonIfUnsupported,
730  "Reference batch matrix multiplication: input Y is not of rank 2 or greater");
731 
732  return supported;
733 }
734 
735 bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
736  const TensorInfo& output,
737  const TensorInfo& mean,
738  const TensorInfo& variance,
739  const TensorInfo& beta,
740  const TensorInfo& gamma,
741  const BatchNormalizationDescriptor& descriptor,
742  Optional<std::string&> reasonIfUnsupported) const
743 {
744  IgnoreUnused(descriptor);
745 
746  std::array<DataType, 6> supportedTypes =
747  {
748  DataType::Float32,
749  DataType::Float16,
750  DataType::QAsymmS8,
751  DataType::QAsymmU8,
752  DataType::QSymmS16
753  };
754 
755  bool supported = true;
756 
757  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
758  "Reference batch normalization: input is not a supported type.");
759 
760  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
761  "Reference batch normalization: output is not a supported type.");
762 
763  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
764  "Reference batch normalization: input and output types are mismatched");
765 
766  supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
767  "Reference batch normalization: mean is not a supported type.");
768 
769  supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
770  "Reference batch normalization: variance is not a supported type.");
771 
772  supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
773  "Reference batch normalization: beta is not a supported type.");
774 
775  supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
776  "Reference batch normalization: gamma is not a supported type.");
777 
778  return supported;
779 }
780 
781 bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
782  const TensorInfo& output,
783  const BatchToSpaceNdDescriptor& descriptor,
784  Optional<std::string&> reasonIfUnsupported) const
785 {
786  IgnoreUnused(descriptor);
787 
788  bool supported = true;
789 
790  std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
791  std::string inputTensorStr = "input";
792  std::string outputTensorStr = "output";
793 
794  // Define supported types.
795  std::array<DataType,6> supportedTypes =
796  {
797  DataType::Float32,
798  DataType::Float16,
799  DataType::QAsymmS8,
800  DataType::QAsymmU8,
801  DataType::QSymmS16
802  };
803 
804  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
805  "Reference BatchToSpaceNd: input type not supported.");
806 
807  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
808  "Reference BatchToSpaceNd: output type not supported.");
809 
810  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
811  "Reference BatchToSpaceNd: input and output types mismatched.");
812 
813  return supported;
814 }
815 
816 bool RefLayerSupport::IsBroadcastToSupported(const TensorInfo& input,
817  const TensorInfo& output,
818  const BroadcastToDescriptor& descriptor,
819  Optional<std::string&> reasonIfUnsupported) const
820 {
821  IgnoreUnused(descriptor);
822 
823  bool supported = true;
824 
825  std::array<DataType, 8> supportedTypes
826  {
827  DataType::Float32,
828  DataType::Float16,
829  DataType::QAsymmS8,
830  DataType::QAsymmU8,
831  DataType::QSymmS8,
832  DataType::QSymmS16,
833  DataType::Signed32,
834  DataType::Signed64
835  };
836 
837  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
838  "BroadcastTo: input type not supported.");
839 
840  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
841  "BroadcastTo: output type not supported");
842 
843  return supported;
844 }
845 
846 bool RefLayerSupport::IsCastSupported(const TensorInfo& input,
847  const TensorInfo& output,
848  Optional<std::string&> reasonIfUnsupported) const
849 {
850  std::array<DataType, 10> supportedInputTypes =
851  {
852  DataType::Float32,
853  DataType::Float16,
854  DataType::QSymmS8,
855  DataType::QAsymmS8,
856  DataType::QAsymmU8,
857  DataType::QSymmS16,
858  DataType::Signed32,
859  DataType::Signed64
860  };
861 
862  bool supported = true;
863  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
864  "Reference cast: input is not a supported type");
865 
866 
867  supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
868  "Reference cast: output is not a supported type");
869 
870  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
871  "Reference cast: input and output shapes have different number of total elements");
872 
873  return supported;
874 }
875 
876 bool RefLayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
877  const TensorInfo& output,
878  const ChannelShuffleDescriptor& descriptor,
879  Optional<std::string&> reasonIfUnsupported) const
880 {
881  IgnoreUnused(descriptor);
882  bool supported = true;
883 
884  // Define supported output and inputs types.
885  std::array<DataType, 7> supportedTypes =
886  {
887  DataType::Float32,
888  DataType::Float16,
889  DataType::QAsymmS8,
890  DataType::QAsymmU8,
891  DataType::QSymmS8,
892  DataType::QSymmS16
893  };
894 
895  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
896  "Reference ChannelShuffle: input is not a supported type.");
897 
898  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
899  "Reference ChannelShuffle: output is not a supported type.");
900 
901  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
902  "Reference ChannelShuffle: input and output types are mismatched.");
903 
904  return supported;
905 }
906 
907 
908 bool RefLayerSupport::IsComparisonSupported(const TensorInfo& input0,
909  const TensorInfo& input1,
910  const TensorInfo& output,
911  const ComparisonDescriptor& descriptor,
912  Optional<std::string&> reasonIfUnsupported) const
913 {
914  IgnoreUnused(descriptor);
915  std::array<DataType, 8> supportedInputTypes =
916  {
917  DataType::Boolean,
918  DataType::Float32,
919  DataType::Float16,
920  DataType::QAsymmS8,
921  DataType::QAsymmU8,
922  DataType::QSymmS16,
923  DataType::Signed32
924  };
925 
926  bool supported = true;
927  supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
928  "Reference comparison: input 0 is not a supported type");
929 
930  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
931  "Reference comparison: input 0 and Input 1 types are mismatched");
932 
933  supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
934  "Reference comparison: output is not of type Boolean");
935 
936  return supported;
937 }
938 
939 bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
940  const TensorInfo& output,
941  const OriginsDescriptor& descriptor,
942  Optional<std::string&> reasonIfUnsupported) const
943 {
944  IgnoreUnused(descriptor);
945 
946  bool supported = true;
947  std::array<DataType,7> supportedTypes =
948  {
949  DataType::Float32,
950  DataType::Float16,
951  DataType::QAsymmS8,
952  DataType::QAsymmU8,
953  DataType::QSymmS16,
954  DataType::Signed32
955  };
956 
957  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
958  "Reference concatenation: output type not supported");
959  for (const TensorInfo* input : inputs)
960  {
961  ARMNN_ASSERT(input != nullptr);
962  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
963  "Reference concatenation: input type not supported");
964 
965  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
966  "Reference concatenation: input and output types mismatched.");
967  }
968 
969  return supported;
970 }
971 
972 bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
973  Optional<std::string&> reasonIfUnsupported) const
974 {
975  std::array<DataType,8> supportedTypes =
976  {
977  DataType::Float16,
978  DataType::Float32,
979  DataType::QAsymmS8,
980  DataType::QAsymmU8,
981  DataType::QSymmS8,
982  DataType::QSymmS16,
983  DataType::Signed32
984  };
985 
986  return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
987  "Reference constant: output is not a supported type.");
988 }
989 
990 bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
991  const TensorInfo& output,
992  Optional<std::string&> reasonIfUnsupported) const
993 {
994  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
995  input.GetDataType(),
996  &TrueFunc<>,
997  &FalseInputFuncF32<>,
998  &FalseFuncU8<>,
999  &FalseFuncI32<>,
1000  &FalseFuncU8<>) &&
1001  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1002  output.GetDataType(),
1003  &FalseOutputFuncF16<>,
1004  &TrueFunc<>,
1005  &FalseFuncU8<>,
1006  &FalseFuncI32<>,
1007  &FalseFuncU8<>));
1008 }
1009 
1010 bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
1011  const TensorInfo& output,
1012  Optional<std::string&> reasonIfUnsupported) const
1013 {
1014  return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1015  input.GetDataType(),
1016  &FalseInputFuncF16<>,
1017  &TrueFunc<>,
1018  &FalseFuncU8<>,
1019  &FalseFuncI32<>,
1020  &FalseFuncU8<>) &&
1021  IsSupportedForDataTypeGeneric(reasonIfUnsupported,
1022  output.GetDataType(),
1023  &TrueFunc<>,
1024  &FalseOutputFuncF32<>,
1025  &FalseFuncU8<>,
1026  &FalseFuncI32<>,
1027  &FalseFuncU8<>));
1028 }
1029 
1030 bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
1031  const TensorInfo& output,
1032  const Convolution2dDescriptor& descriptor,
1033  const TensorInfo& weights,
1034  const Optional<TensorInfo>& biases,
1035  Optional<std::string&> reasonIfUnsupported) const
1036 {
1037  bool supported = true;
1038 
1039  // Define supported types.
1040  std::array<DataType,7> supportedTypes =
1041  {
1042  DataType::Float32,
1043  DataType::Float16,
1044  DataType::QAsymmS8,
1045  DataType::QAsymmU8,
1046  DataType::QSymmS8,
1047  DataType::QSymmS16
1048  };
1049 
1050  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1051  "Reference Convolution2d: input is not a supported type.");
1052 
1053  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1054  "Reference Convolution2d: output is not a supported type.");
1055 
1056  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1057  "Reference Convolution2d: input and output types mismatched.");
1058 
1059 
1060  const DataType inputType = input.GetDataType();
1061  if (IsQuantized8BitType(inputType))
1062  {
1063  std::array<DataType, 3> supportedWeightTypes =
1064  {
1065  DataType::QAsymmS8,
1066  DataType::QAsymmU8,
1067  DataType::QSymmS8
1068  };
1069 
1070  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1071  "Reference Convolution2d: weights type not supported for quantized input.");
1072  }
1073  else
1074  {
1075  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1076  "Reference Convolution2d: weights is not a supported type.");
1077 
1078  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1079  "Reference Convolution2d: input and weights types mismatched.");
1080  }
1081 
1082  if (biases.has_value())
1083  {
1084  std::array<DataType,4> biasesSupportedTypes =
1085  {
1086  DataType::Float32,
1087  DataType::Float16,
1088  DataType::Signed32
1089  };
1090 
1091  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1092  "Reference Convolution2d: biases is not a supported type.");
1093  }
1094  IgnoreUnused(descriptor);
1095 
1096  return supported;
1097 }
1098 
1099 bool RefLayerSupport::IsConvolution3dSupported(const TensorInfo& input,
1100  const TensorInfo& output,
1101  const Convolution3dDescriptor& descriptor,
1102  const TensorInfo& weights,
1103  const Optional<TensorInfo>& biases,
1104  Optional<std::string&> reasonIfUnsupported) const
1105 {
1106  bool supported = true;
1107 
1108  // Define supported types.
1109  std::array<DataType,7> supportedTypes =
1110  {
1111  DataType::Float32,
1112  DataType::Float16,
1113  DataType::QAsymmS8,
1114  DataType::QAsymmU8,
1115  DataType::QSymmS8,
1116  DataType::QSymmS16
1117  };
1118 
1119  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1120  "Reference Convolution3d: input is not a supported type.");
1121 
1122  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1123  "Reference Convolution3d: output is not a supported type.");
1124 
1125  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1126  "Reference Convolution3d: input and output types mismatched.");
1127 
1128  const DataType inputType = input.GetDataType();
1129  if (IsQuantized8BitType(inputType))
1130  {
1131  std::array<DataType, 3> supportedWeightTypes =
1132  {
1133  DataType::QAsymmS8,
1134  DataType::QAsymmU8,
1135  DataType::QSymmS8
1136  };
1137 
1138  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1139  "Reference Convolution3d: weights type not supported for quantized input.");
1140  }
1141  else
1142  {
1143  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1144  "Reference Convolution3d: weights is not a supported type.");
1145 
1146  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1147  "Reference Convolution3d: input and weights types mismatched.");
1148  }
1149 
1150  if (biases.has_value())
1151  {
1152  std::array<DataType,4> biasesSupportedTypes =
1153  {
1154  DataType::Float32,
1155  DataType::Float16,
1156  DataType::Signed32
1157  };
1158 
1159  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1160  "Reference Convolution3d: biases is not a supported type.");
1161  }
1162  IgnoreUnused(descriptor);
1163 
1164  return supported;
1165 }
1166 
1167 bool RefLayerSupport::IsDebugSupported(const TensorInfo& input,
1168  const TensorInfo& output,
1169  Optional<std::string&> reasonIfUnsupported) const
1170 {
1171  bool supported = true;
1172 
1173  std::array<DataType, 8> supportedTypes =
1174  {
1175  DataType::BFloat16,
1176  DataType::Float16,
1177  DataType::Float32,
1178  DataType::QAsymmS8,
1179  DataType::QAsymmU8,
1180  DataType::QSymmS8,
1181  DataType::QSymmS16,
1182  DataType::Signed32
1183  };
1184 
1185  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1186  "Reference for Debug layer: input type not supported");
1187 
1188  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1189  "Reference for Debug layer: output type not supported");
1190 
1191  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1192  "Reference for Debug layer: input and output types are mismatched");
1193 
1194  return supported;
1195 }
1196 
1197 bool RefLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
1198  const TensorInfo& output,
1199  const DepthToSpaceDescriptor& descriptor,
1200  Optional<std::string&> reasonIfUnsupported) const
1201 {
1202  IgnoreUnused(descriptor);
1203  bool supported = true;
1204 
1205  std::array<DataType,6> supportedTypes =
1206  {
1207  DataType::Float32,
1208  DataType::Float16,
1209  DataType::QAsymmS8,
1210  DataType::QAsymmU8,
1211  DataType::QSymmS16
1212  };
1213 
1214  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1215  "Reference DepthToSpace: input type not supported");
1216 
1217  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1218  "Reference DepthToSpace: output type not supported");
1219 
1220  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1221  "Reference DepthToSpace: input and output types are mismatched");
1222 
1223  return supported;
1224 }
1225 
1226 bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
1227  const TensorInfo& output,
1228  const DepthwiseConvolution2dDescriptor& descriptor,
1229  const TensorInfo& weights,
1230  const Optional<TensorInfo>& biases,
1231  Optional<std::string&> reasonIfUnsupported) const
1232 {
1233  IgnoreUnused(descriptor);
1234  bool supported = true;
1235 
1236  // Define supported types.
1237  std::array<DataType,7> supportedTypes =
1238  {
1239  DataType::Float32,
1240  DataType::Float16,
1241  DataType::QAsymmS8,
1242  DataType::QAsymmU8,
1243  DataType::QSymmS8,
1244  DataType::QSymmS16
1245  };
1246 
1247  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1248  "Reference DepthwiseConvolution2d: input is not a supported type.");
1249 
1250  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1251  "Reference DepthwiseConvolution2d: output is not a supported type.");
1252 
1253  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1254  "Reference DepthwiseConvolution2d: input and output types mismatched.");
1255 
1256  const DataType inputType = input.GetDataType();
1257  if (IsQuantized8BitType(inputType))
1258  {
1259  std::array<DataType, 3> supportedWeightTypes =
1260  {
1261  DataType::QAsymmS8,
1262  DataType::QAsymmU8,
1263  DataType::QSymmS8,
1264  };
1265 
1266  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1267  "Reference DepthwiseConvolution2d: weights type not supported for "
1268  "quantized input.");
1269  }
1270  else
1271  {
1272  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1273  "Reference DepthwiseConvolution2d: weights is not a supported type.");
1274 
1275  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1276  "Reference DepthwiseConvolution2d: input and weights types mismatched.");
1277  }
1278 
1279  if (biases.has_value())
1280  {
1281  std::array<DataType,4> biasesSupportedTypes =
1282  {
1283  DataType::Float32,
1284  DataType::Float16,
1285  DataType::Signed32
1286  };
1287  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1288  "Reference DepthwiseConvolution2d: biases is not a supported type.");
1289  }
1290 
1291  return supported;
1292 
1293 }
1294 
1295 bool RefLayerSupport::IsDequantizeSupported(const TensorInfo& input,
1296  const TensorInfo& output,
1297  Optional<std::string&> reasonIfUnsupported) const
1298 {
1299  bool supported = true;
1300 
1301  std::array<DataType,5> supportedInputTypes = {
1302  DataType::QAsymmS8,
1303  DataType::QAsymmU8,
1304  DataType::QSymmS8,
1305  DataType::QSymmS16,
1306  DataType::Float16
1307  };
1308 
1309  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1310  "Reference for Dequantize layer: input type not supported.");
1311 
1312  supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
1313  "Reference for Dequantize layer: per-axis quantized input not supported.");
1314 
1315  std::array<DataType,3> supportedOutputTypes = {
1316  DataType::Float32,
1317  DataType::Float16
1318  };
1319 
1320  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1321  "Reference for Dequantize layer: output type not supported.");
1322 
1323  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1324  "Reference for Dequantize layer: input/output shapes have different num total "
1325  "elements.");
1326 
1327  return supported;
1328 }
1329 
1330 bool RefLayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
1331  const TensorInfo& scores,
1332  const TensorInfo& anchors,
1333  const TensorInfo& detectionBoxes,
1334  const TensorInfo& detectionClasses,
1335  const TensorInfo& detectionScores,
1336  const TensorInfo& numDetections,
1337  const DetectionPostProcessDescriptor& descriptor,
1338  Optional<std::string&> reasonIfUnsupported) const
1339 {
1340  IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
1341 
1342  bool supported = true;
1343 
1344  std::array<DataType,6> supportedInputTypes =
1345  {
1346  DataType::Float32,
1347  DataType::Float16,
1348  DataType::QAsymmS8,
1349  DataType::QAsymmU8,
1350  DataType::QSymmS16
1351  };
1352 
1353  supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
1354  "Reference DetectionPostProcess: input 0 is not a supported type.");
1355 
1356  supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
1357  "Reference DetectionPostProcess: input 1 is not a supported type.");
1358 
1359  return supported;
1360 }
1361 
1362 bool RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
1363  const TensorInfo& output,
1364  const DepthwiseConvolution2dDescriptor& descriptor,
1365  const TensorInfo& weights,
1366  const Optional<TensorInfo>& biases,
1367  Optional<std::string&> reasonIfUnsupported) const
1368 {
1369  return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
1370 }
1371 
1372 bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
1373  const TensorInfo& input1,
1374  const TensorInfo& output,
1375  Optional<std::string&> reasonIfUnsupported) const
1376 {
1377  bool supported = true;
1378 
1379  std::array<DataType,7> supportedTypes = {
1380  DataType::Float32,
1381  DataType::Float16,
1382  DataType::QAsymmS8,
1383  DataType::QAsymmU8,
1384  DataType::QSymmS16,
1385  DataType::Signed32
1386  };
1387 
1388  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1389  "Reference division: input 0 is not a supported type.");
1390 
1391  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1392  "Reference division: input 1 is not a supported type.");
1393 
1394  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1395  "Reference division: output is not a supported type.");
1396 
1397  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1398  "Reference division: input 0 and Input 1 types are mismatched");
1399 
1400  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1401  "Reference division: input and output types are mismatched");
1402 
1403  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1404  "Reference division: shapes are not suitable for implicit broadcast.");
1405 
1406  return supported;
1407 }
1408 
1409 bool RefLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
1410  const TensorInfo& output,
1411  const ElementwiseUnaryDescriptor& descriptor,
1412  Optional<std::string&> reasonIfUnsupported) const
1413 {
1414  IgnoreUnused(descriptor);
1415 
1416  std::array<DataType, 7> supportedTypes =
1417  {
1418  DataType::Float32,
1419  DataType::Float16,
1420  DataType::QAsymmS8,
1421  DataType::QAsymmU8,
1422  DataType::QSymmS16,
1423  DataType::Signed32
1424  };
1425 
1426  std::array<DataType, 1> logicalSupportedTypes =
1427  {
1428  DataType::Boolean
1429  };
1430 
1431  bool supported = true;
1432 
1433  if (descriptor.m_Operation == UnaryOperation::LogicalNot)
1434  {
1435  supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
1436  "Reference elementwise unary: input type not supported");
1437 
1438  supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
1439  "Reference elementwise unary: output type not supported");
1440  }
1441  else
1442  {
1443  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1444  "Reference elementwise unary: input type not supported");
1445 
1446  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1447  "Reference elementwise unary: output type not supported");
1448  }
1449 
1450  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1451  "Reference elementwise unary: input and output types not matching");
1452 
1453  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1454  "Reference elementwise unary: input and output shapes"
1455  "have different number of total elements");
1456 
1457  return supported;
1458 }
1459 
1460 bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
1461  const FakeQuantizationDescriptor& descriptor,
1462  Optional<std::string&> reasonIfUnsupported) const
1463 {
1464  IgnoreUnused(descriptor);
1465  bool supported = true;
1466 
1467  std::array<DataType,1> supportedTypes =
1468  {
1469  DataType::Float32
1470  };
1471 
1472  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1473  "Reference fake quantization: input type not supported.");
1474 
1475  return supported;
1476 }
1477 
1478 bool RefLayerSupport::IsFillSupported(const TensorInfo& input,
1479  const TensorInfo& output,
1480  const FillDescriptor& descriptor,
1481  Optional<std::string&> reasonIfUnsupported) const
1482 {
1483  IgnoreUnused(descriptor);
1484  IgnoreUnused(output);
1485 
1486  bool supported = true;
1487 
1488  std::array<DataType,3> supportedTypes =
1489  {
1490  DataType::Float32,
1491  DataType::Float16,
1492  DataType::Signed32
1493  };
1494 
1495  supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
1496  "Reference Fill: input type not supported.");
1497 
1498  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1499  "Reference Fill: output type not supported.");
1500  return supported;
1501 }
1502 
1503 bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
1504  const TensorInfo& output,
1505  Optional<std::string&> reasonIfUnsupported) const
1506 {
1507  IgnoreUnused(output);
1508  bool supported = true;
1509 
1510  std::array<DataType,3> supportedTypes =
1511  {
1512  DataType::Float32,
1513  DataType::Float16
1514  };
1515 
1516  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1517  "Reference Floor: input type not supported.");
1518 
1519  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1520  "Reference Floor: output type not supported.");
1521 
1522  return supported;
1523 }
1524 
1525 bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
1526  const TensorInfo& output,
1527  const TensorInfo& weights,
1528  const TensorInfo& biases,
1529  const FullyConnectedDescriptor& descriptor,
1530  Optional<std::string&> reasonIfUnsupported) const
1531 {
1532  bool supported = true;
1533 
1534  // Define supported types.
1535  std::array<DataType,6> supportedTypes =
1536  {
1537  DataType::Float32,
1538  DataType::Float16,
1539  DataType::QAsymmS8,
1540  DataType::QAsymmU8,
1541  DataType::QSymmS16
1542  };
1543 
1544  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1545  "Reference Fully Connected: input type not supported.");
1546 
1547  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1548  "Reference Fully Connected: output type not supported.");
1549 
1550  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1551  "Reference Fully Connected: weights type not supported.");
1552 
1553  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1554  "Reference Fully Connected: input and output types mismatched.");
1555 
1556  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1557  "Reference Fully Connected: weights is not a supported type.");
1558 
1559  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1560  "Reference Fully Connected: input and weights types mismatched.");
1561 
1562  if (descriptor.m_BiasEnabled)
1563  {
1564  // Defined supported types for bias
1565  std::array<DataType, 5>
1566  supportedBiasTypes =
1567  {
1568  DataType::Float32,
1569  DataType::Float16,
1570  DataType::Signed32,
1571  DataType::QAsymmS8
1572  };
1573 
1574  supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
1575  "Reference Fully Connected: bias type not supported.");
1576 
1577  supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
1578  "Reference Fully Connected: bias and weight types mismatch.");
1579 
1580  supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
1581  "Reference Fully Connected: bias type inferred from weights is incompatible.");
1582 
1583  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
1584  "Reference Fully Connected: bias must have 1 dimension.");
1585 
1586  }
1587 
1588  return supported;
1589 }
1590 
1591 bool RefLayerSupport::IsGatherNdSupported(const armnn::TensorInfo& input0,
1592  const armnn::TensorInfo& input1,
1593  const armnn::TensorInfo& output,
1594  armnn::Optional<std::string&> reasonIfUnsupported) const
1595 {
1596  bool supported = true;
1597  std::array<DataType,7> supportedTypes =
1598  {
1599  DataType::Float32,
1600  DataType::Float16,
1601  DataType::QAsymmS8,
1602  DataType::QAsymmU8,
1603  DataType::QSymmS16,
1604  DataType::Signed32
1605  };
1606 
1607  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1608  "Reference GatherNd: input type not supported");
1609 
1610  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1611  "Reference GatherNd: output type not supported");
1612 
1613  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1614  "Reference GatherNd: indices (input1) type not supported");
1615 
1616  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1617  "Reference GatherNd: input and output types not matching");
1618 
1619  return supported;
1620 }
1621 
1622 bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
1623  const armnn::TensorInfo& input1,
1624  const armnn::TensorInfo& output,
1625  const GatherDescriptor& descriptor,
1626  armnn::Optional<std::string&> reasonIfUnsupported) const
1627 {
1628  bool supported = true;
1629  std::array<DataType,7> supportedTypes =
1630  {
1631  DataType::Float32,
1632  DataType::Float16,
1633  DataType::QAsymmS8,
1634  DataType::QAsymmU8,
1635  DataType::QSymmS16,
1636  DataType::Signed32
1637  };
1638 
1639  IgnoreUnused(descriptor);
1640  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1641  "Reference Gather: input type not supported");
1642 
1643  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1644  "Reference Gather: output type not supported");
1645 
1646  supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1647  "Reference Gather: indices (input1) type not supported");
1648 
1649  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1650  "Reference Gather: input and output types not matching");
1651 
1652  return supported;
1653 }
1654 
1655 bool RefLayerSupport::IsInputSupported(const TensorInfo& /*input*/,
1656  Optional<std::string&> /*reasonIfUnsupported*/) const
1657 {
1658  return true;
1659 }
1660 
1661 bool RefLayerSupport::IsInstanceNormalizationSupported(const TensorInfo& input,
1662  const TensorInfo& output,
1663  const InstanceNormalizationDescriptor& descriptor,
1664  Optional<std::string&> reasonIfUnsupported) const
1665 {
1666  IgnoreUnused(descriptor);
1667  // Define supported types
1668  std::array<DataType, 3> supportedTypes =
1669  {
1670  DataType::Float32,
1671  DataType::Float16
1672  };
1673 
1674  bool supported = true;
1675 
1676  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1677  "Reference Instance Normalization: input type not supported.");
1678 
1679  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1680  "Reference Instance Normalization: output type not supported.");
1681 
1682  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1683  "Reference Instance Normalization: input and output types mismatched.");
1684 
1685  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1686  "Reference Instance Normalization: input and output shapes have different "
1687  "num total elements.");
1688 
1689  return supported;
1690 }
1691 
1692 bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
1693  const TensorInfo& output,
1694  const L2NormalizationDescriptor& descriptor,
1695  Optional<std::string&> reasonIfUnsupported) const
1696 {
1697  IgnoreUnused(descriptor);
1698  // Define supported types
1699  std::array<DataType, 6> supportedTypes =
1700  {
1701  DataType::Float32,
1702  DataType::Float16,
1703  DataType::QAsymmS8,
1704  DataType::QAsymmU8,
1705  DataType::QSymmS16
1706  };
1707 
1708  bool supported = true;
1709 
1710  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1711  "Reference L2normalization: input type not supported.");
1712 
1713  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1714  "Reference L2normalization: output type not supported.");
1715 
1716  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1717  "Reference L2normalization: input and output types mismatched.");
1718 
1719  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1720  "Reference L2normalization: input and output shapes have different "
1721  "num total elements.");
1722 
1723  return supported;
1724 }
1725 
1726 bool RefLayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
1727  const TensorInfo& input1,
1728  const TensorInfo& output,
1729  const LogicalBinaryDescriptor& descriptor,
1730  Optional<std::string&> reasonIfUnsupported) const
1731 {
1732  IgnoreUnused(descriptor);
1733 
1734  std::array<DataType, 1> supportedTypes =
1735  {
1736  DataType::Boolean
1737  };
1738 
1739  bool supported = true;
1740  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1741  "Reference LogicalBinary: input 0 type not supported");
1742  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1743  "Reference LogicalBinary: input 1 type not supported");
1744 
1745  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1746  "Reference LogicalBinary: input and output types do not match");
1747 
1748  return supported;
1749 }
1750 
1751 bool RefLayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
1752  const TensorInfo& output,
1753  const LogSoftmaxDescriptor& descriptor,
1754  Optional<std::string&> reasonIfUnsupported) const
1755 {
1756  IgnoreUnused(descriptor);
1757 
1758  std::array<DataType, 3> supportedTypes =
1759  {
1760  DataType::Float32,
1761  DataType::Float16
1762  };
1763 
1764  bool supported = true;
1765  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1766  "Reference LogSoftmax: input type not supported");
1767 
1768  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1769  "Reference LogSoftmax: output type not supported");
1770 
1771  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1772  "Reference LogSoftmax: input and output types do not match");
1773 
1774  return supported;
1775 }
1776 
1777 bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
1778  const TensorInfo& outputStateIn,
1779  const TensorInfo& cellStateIn,
1780  const TensorInfo& scratchBuffer,
1781  const TensorInfo& outputStateOut,
1782  const TensorInfo& cellStateOut,
1783  const TensorInfo& output,
1784  const LstmDescriptor& descriptor,
1785  const LstmInputParamsInfo& paramsInfo,
1786  Optional<std::string&> reasonIfUnsupported) const
1787 {
1788  IgnoreUnused(descriptor);
1789  IgnoreUnused(paramsInfo);
1790 
1791  bool supported = true;
1792 
1793  std::array<DataType,3> supportedTypes = {
1794  DataType::Float32,
1795  DataType::QSymmS16
1796  };
1797 
1798  // check inputs and outputs
1799  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1800  "Reference Lstm: input is not a supported type.");
1801  supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1802  "Reference Lstm: input and outputStateIn types are mismatched");
1803  supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1804  "Reference Lstm: input and cellStateIn types are mismatched");
1805  supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1806  "Reference Lstm: input and scratchBuffer types are mismatched");
1807  supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1808  "Reference Lstm: input and outputStateOut types are mismatched");
1809  supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1810  "Reference Lstm: input and cellStateOut types are mismatched");
1811 
1812  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1813  "Reference Lstm: input and output types are mismatched");
1814  // check layer parameters
1815  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
1816  "Reference Lstm: input and InputToForgetWeights types are mismatched");
1817  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
1818  "Reference Lstm: input and InputToCellWeights types are mismatched");
1819  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
1820  "Reference Lstm: input and InputToOutputWeights types are mismatched");
1821  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
1822  "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
1823  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
1824  "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
1825  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
1826  "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
1827  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
1828  "Reference Lstm: input and ForgetGateBias types are mismatched");
1829  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
1830  "Reference Lstm: input and CellBias types are mismatched");
1831  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
1832  "Reference Lstm: input and OutputGateBias types are mismatched");
1833  if (!descriptor.m_CifgEnabled)
1834  {
1835  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
1836  "Reference Lstm: input and InputToInputWeights types are mismatched");
1837  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
1838  reasonIfUnsupported,
1839  "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
1840  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
1841  "Reference Lstm: input and InputGateBias types are mismatched");
1842  if (descriptor.m_PeepholeEnabled)
1843  {
1844  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
1845  reasonIfUnsupported,
1846  "Reference Lstm: input and CellToInputWeights types are mismatched");
1847  }
1848  }
1849  if (descriptor.m_PeepholeEnabled)
1850  {
1851  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
1852  "Reference Lstm: input and CellToForgetWeights types are mismatched");
1853  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
1854  "Reference Lstm: input and CellToOutputWeights types are mismatched");
1855  }
1856  if (descriptor.m_ProjectionEnabled)
1857  {
1858  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
1859  "Reference Lstm: input and mProjectionWeights types are mismatched");
1860  if (paramsInfo.m_ProjectionBias != nullptr)
1861  {
1862  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
1863  "Reference Lstm: input and ProjectionBias types are mismatched");
1864  }
1865  }
1866  if (descriptor.m_LayerNormEnabled)
1867  {
1868  if (!descriptor.m_CifgEnabled)
1869  {
1870  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
1871  reasonIfUnsupported,
1872  "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1873  }
1874  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
1875  reasonIfUnsupported,
1876  "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
1877  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
1878  reasonIfUnsupported,
1879  "Reference Lstm: input and CellLayerNormWeights types are mismatched");
1880  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
1881  reasonIfUnsupported,
1882  "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1883  }
1884 
1885  return supported;
1886 }
1887 
1888 bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
1889  const TensorInfo& input1,
1890  const TensorInfo& output,
1891  Optional<std::string&> reasonIfUnsupported) const
1892 {
1893  bool supported = true;
1894 
1895  std::array<DataType,7> supportedTypes = {
1896  DataType::Float32,
1897  DataType::Float16,
1898  DataType::QAsymmS8,
1899  DataType::QAsymmU8,
1900  DataType::QSymmS16,
1901  DataType::Signed32
1902  };
1903 
1904  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1905  "Reference maximum: input 0 is not a supported type.");
1906 
1907  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1908  "Reference maximum: input 1 is not a supported type.");
1909 
1910  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1911  "Reference maximum: output is not a supported type.");
1912 
1913  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1914  "Reference maximum: input 0 and Input 1 types are mismatched");
1915 
1916  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1917  "Reference maximum: input and output types are mismatched");
1918 
1919  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1920  "Reference maximum: shapes are not suitable for implicit broadcast.");
1921 
1922  return supported;
1923 }
1924 
1925 bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
1926  const TensorInfo& output,
1927  const MeanDescriptor& descriptor,
1928  Optional<std::string&> reasonIfUnsupported) const
1929 {
1930  bool supported = true;
1931  std::string meanLayerStr = "Mean";
1932  std::string outputTensorStr = "output";
1933 
1934  std::array<DataType,6> supportedTypes =
1935  {
1936  DataType::Float32,
1937  DataType::Float16,
1938  DataType::QAsymmS8,
1939  DataType::QAsymmU8,
1940  DataType::QSymmS16
1941  };
1942 
1943  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1944  "Reference Mean: input type not supported.");
1945 
1946  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1947  "Reference Mean: input and output types are mismatched");
1948 
1949  if (descriptor.m_KeepDims)
1950  {
1951  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1952  reasonIfUnsupported,
1953  CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1954  output.GetNumDimensions(),
1955  meanLayerStr, outputTensorStr).data());
1956  }
1957  else if (descriptor.m_Axis.empty())
1958  {
1959  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1960  reasonIfUnsupported,
1961  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1962  meanLayerStr, outputTensorStr).data());
1963  }
1964  else
1965  {
1966  auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1967 
1968  if (outputDim > 0)
1969  {
1970  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1971  reasonIfUnsupported,
1972  CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1973  meanLayerStr, outputTensorStr).data());
1974  }
1975  else
1976  {
1977  supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1978  reasonIfUnsupported,
1979  CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1980  meanLayerStr, outputTensorStr).data());
1981  }
1982  }
1983 
1984  return supported;
1985 }
1986 
1987 bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
1988  const TensorInfo &output,
1989  Optional<std::string &> reasonIfUnsupported) const
1990 {
1991  bool supported = true;
1992 
1993  std::array<DataType,7> supportedTypes =
1994  {
1995  DataType::BFloat16,
1996  DataType::Float32,
1997  DataType::Float16,
1998  DataType::QAsymmS8,
1999  DataType::QAsymmU8,
2000  DataType::QSymmS16,
2001  DataType::Boolean
2002  };
2003 
2004  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2005  "Reference MemCopy: input type not supported");
2006 
2007  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2008  "Reference MemCopy: output type not supported");
2009 
2010  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2011  "Reference MemCopy: input and output types are mismatched");
2012 
2013  return supported;
2014 }
2015 
2016 bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
2017  const TensorInfo& input1,
2018  const TensorInfo& output,
2019  Optional<std::string&> reasonIfUnsupported) const
2020 {
2021  bool supported = true;
2022 
2023  std::array<DataType,7> supportedTypes = {
2024  DataType::Float32,
2025  DataType::Float16,
2026  DataType::QAsymmS8,
2027  DataType::QAsymmU8,
2028  DataType::QSymmS16,
2029  DataType::Signed32
2030  };
2031 
2032  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2033  "Reference minimum: input 0 is not a supported type.");
2034 
2035  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2036  "Reference minimum: input 1 is not a supported type.");
2037 
2038  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2039  "Reference minimum: output is not a supported type.");
2040 
2041  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2042  "Reference minimum: input 0 and Input 1 types are mismatched");
2043 
2044  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2045  "Reference minimum: input and output types are mismatched");
2046 
2047  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2048  "Reference minimum: shapes are not suitable for implicit broadcast.");
2049 
2050  return supported;
2051 }
2052 
2053 bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
2054  const TensorInfo& input1,
2055  const TensorInfo& output,
2056  Optional<std::string&> reasonIfUnsupported) const
2057 {
2058  bool supported = true;
2059 
2060  std::array<DataType,7> supportedTypes = {
2061  DataType::Float32,
2062  DataType::Float16,
2063  DataType::QAsymmS8,
2064  DataType::QAsymmU8,
2065  DataType::QSymmS16,
2066  DataType::Signed32
2067  };
2068 
2069  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2070  "Reference multiplication: input 0 is not a supported type.");
2071 
2072  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2073  "Reference multiplication: input 1 is not a supported type.");
2074 
2075  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2076  "Reference multiplication: output is not a supported type.");
2077 
2078  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2079  "Reference multiplication: input 0 and Input 1 types are mismatched");
2080 
2081  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2082  "Reference multiplication: input and output types are mismatched");
2083 
2084  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2085  "Reference multiplication: shapes are not suitable for implicit broadcast.");
2086 
2087  return supported;
2088 }
2089 
2090 bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
2091  const TensorInfo& output,
2092  const NormalizationDescriptor& descriptor,
2093  Optional<std::string&> reasonIfUnsupported) const
2094 {
2095  IgnoreUnused(descriptor);
2096 
2097  // Define supported types
2098  std::array<DataType, 6> supportedTypes =
2099  {
2100  DataType::Float16,
2101  DataType::Float32,
2102  DataType::QAsymmS8,
2103  DataType::QAsymmU8,
2104  DataType::QSymmS16
2105  };
2106 
2107  bool supported = true;
2108 
2109  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2110  "Reference normalization: input type not supported.");
2111 
2112  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2113  "Reference normalization: output type not supported.");
2114 
2115  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
2116  "Reference normalization: input and output shapes have different "
2117  "num total elements.");
2118 
2119  return supported;
2120 }
2121 
2122 bool RefLayerSupport::IsOutputSupported(const TensorInfo& /*output*/,
2123  Optional<std::string&> /*reasonIfUnsupported*/) const
2124 {
2125  return true;
2126 }
2127 
2128 bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
2129  const TensorInfo& output,
2130  const PadDescriptor& descriptor,
2131  Optional<std::string&> reasonIfUnsupported) const
2132 {
2133  IgnoreUnused(descriptor);
2134  bool supported = true;
2135 
2136  // Define supported output and inputs types.
2137  std::array<DataType,6> supportedTypes =
2138  {
2139  DataType::Float32,
2140  DataType::Float16,
2141  DataType::QAsymmS8,
2142  DataType::QAsymmU8,
2143  DataType::QSymmS16
2144  };
2145 
2146  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2147  "Reference pad: input is not a supported type.");
2148 
2149  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2150  "Reference pad: output is not a supported type.");
2151 
2152  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2153  "Reference pad: input and output types are mismatched.");
2154 
2155  return supported;
2156 }
2157 
2158 bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
2159  const TensorInfo& output,
2160  const PermuteDescriptor& descriptor,
2161  Optional<std::string&> reasonIfUnsupported) const
2162 {
2163  IgnoreUnused(descriptor);
2164  bool supported = true;
2165 
2166  // Define supported output and inputs types.
2167  std::array<DataType, 6> supportedTypes =
2168  {
2169  DataType::BFloat16,
2170  DataType::Float32,
2171  DataType::Float16,
2172  DataType::QAsymmS8,
2173  DataType::QAsymmU8,
2174  DataType::QSymmS16
2175  };
2176 
2177  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2178  "Reference permute: input is not a supported type.");
2179 
2180  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2181  "Reference permute: output is not a supported type.");
2182 
2183  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2184  "Reference permute: input and output types are mismatched.");
2185 
2186  return supported;
2187 }
2188 
2189 bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
2190  const TensorInfo& output,
2191  const Pooling2dDescriptor& descriptor,
2192  Optional<std::string&> reasonIfUnsupported) const
2193 {
2194  IgnoreUnused(descriptor);
2195  bool supported = true;
2196 
2197  // Define supported output and inputs types.
2198  std::array<DataType,6> supportedTypes =
2199  {
2200  DataType::Float32,
2201  DataType::Float16,
2202  DataType::QAsymmS8,
2203  DataType::QAsymmU8,
2204  DataType::QSymmS16
2205  };
2206 
2207  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2208  "Reference poolind2d: input is not a supported type.");
2209 
2210  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2211  "Reference poolind2d: output is not a supported type.");
2212 
2213  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2214  "Reference poolind2d: input and output types are mismatched.");
2215 
2216  return supported;
2217 }
2218 
2219 bool RefLayerSupport::IsPooling3dSupported(const TensorInfo& input,
2220  const TensorInfo& output,
2221  const Pooling3dDescriptor& descriptor,
2222  Optional<std::string&> reasonIfUnsupported) const
2223 {
2224  IgnoreUnused(descriptor);
2225  bool supported = true;
2226 
2227  // Define supported output and inputs types.
2228  std::array<DataType,6> supportedTypes =
2229  {
2230  DataType::Float32,
2231  DataType::Float16,
2232  DataType::QAsymmS8,
2233  DataType::QAsymmU8,
2234  DataType::QSymmS16
2235  };
2236 
2237  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2238  "Reference poolind3d: input is not a supported type.");
2239 
2240  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2241  "Reference poolind3d: output is not a supported type.");
2242 
2243  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2244  "Reference poolind3d: input and output types are mismatched.");
2245 
2246  return supported;
2247 }
2248 
2249 
2250 bool RefLayerSupport::IsQLstmSupported(const TensorInfo& input,
2251  const TensorInfo& previousOutputIn,
2252  const TensorInfo& previousCellStateIn,
2253  const TensorInfo& outputStateOut,
2254  const TensorInfo& cellStateOut,
2255  const TensorInfo& output,
2256  const QLstmDescriptor& descriptor,
2257  const LstmInputParamsInfo& paramsInfo,
2258  Optional<std::string&> reasonIfUnsupported) const
2259 {
2260  IgnoreUnused(input);
2261  IgnoreUnused(previousOutputIn);
2262  IgnoreUnused(previousCellStateIn);
2263  IgnoreUnused(outputStateOut);
2264  IgnoreUnused(cellStateOut);
2265  IgnoreUnused(output);
2266  IgnoreUnused(descriptor);
2267  IgnoreUnused(paramsInfo);
2268 
2269  IgnoreUnused(reasonIfUnsupported);
2270 
2271  return true;
2272 }
2273 
2274 bool RefLayerSupport::IsQuantizeSupported(const TensorInfo& input,
2275  const TensorInfo& output,
2276  Optional<std::string&> reasonIfUnsupported) const
2277 {
2278  bool supported = true;
2279 
2280  // Define supported input types.
2281  std::array<DataType,7> supportedInputTypes = {
2282  DataType::Float32,
2283  DataType::Float16,
2284  DataType::QAsymmS8,
2285  DataType::QAsymmU8,
2286  DataType::QSymmS8,
2287  DataType::QSymmS16
2288  };
2289 
2290  supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
2291  "Reference quantize: input type not supported.");
2292 
2293  // Define supported output types.
2294  std::array<DataType,4> supportedOutputTypes = {
2295  DataType::QAsymmS8,
2296  DataType::QAsymmU8,
2297  DataType::QSymmS8,
2298  DataType::QSymmS16
2299  };
2300  supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
2301  "Reference quantize: output type not supported.");
2302 
2303  supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
2304  "Reference quantize: input and output shapes have different num total elements.");
2305 
2306  return supported;
2307 }
2308 
2309 bool RefLayerSupport::IsRankSupported(const TensorInfo& input,
2310  const TensorInfo& output,
2311  Optional<std::string&> reasonIfUnsupported) const
2312 {
2313  IgnoreUnused(input);
2314  // Define supported output types.
2315  std::array<DataType,1> supportedOutputTypes =
2316  {
2317  DataType::Signed32,
2318  };
2319 
2320  return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
2321  "Reference rank: input type not supported.");
2322 }
2323 
2324 bool RefLayerSupport::IsReduceSupported(const TensorInfo& input,
2325  const TensorInfo& output,
2326  const ReduceDescriptor& descriptor,
2327  Optional<std::string&> reasonIfUnsupported) const
2328 {
2329  IgnoreUnused(descriptor);
2330  bool supported = true;
2331  std::array<DataType,7> supportedTypes =
2332  {
2333  DataType::Float32,
2334  DataType::Float16,
2335  DataType::QAsymmS8,
2336  DataType::QAsymmU8,
2337  DataType::QSymmS16,
2338  DataType::Signed32
2339  };
2340 
2341  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2342  "Reference Reduce: input type not supported");
2343 
2344  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2345  "Reference Reduce: output type not supported");
2346 
2347  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2348  "Reference Reduce: input and output types not matching");
2349 
2350  return supported;
2351 }
2352 
2353 bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
2354  const TensorInfo& output,
2355  const ReshapeDescriptor& descriptor,
2356  Optional<std::string&> reasonIfUnsupported) const
2357 {
2358  IgnoreUnused(output);
2359  IgnoreUnused(descriptor);
2360  // Define supported output types.
2361  std::array<DataType,8> supportedOutputTypes =
2362  {
2363  DataType::BFloat16,
2364  DataType::Float32,
2365  DataType::Float16,
2366  DataType::Signed32,
2367  DataType::QAsymmS8,
2368  DataType::QAsymmU8,
2369  DataType::QSymmS16,
2370  DataType::Boolean
2371  };
2372 
2373  return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
2374  "Reference reshape: input type not supported.");
2375 }
2376 
2377 bool RefLayerSupport::IsResizeSupported(const TensorInfo& input,
2378  const TensorInfo& output,
2379  const ResizeDescriptor& descriptor,
2380  Optional<std::string&> reasonIfUnsupported) const
2381 {
2382  IgnoreUnused(descriptor);
2383  bool supported = true;
2384  std::array<DataType,7> supportedTypes =
2385  {
2386  DataType::BFloat16,
2387  DataType::Float32,
2388  DataType::Float16,
2389  DataType::QAsymmS8,
2390  DataType::QAsymmU8,
2391  DataType::QSymmS8,
2392  DataType::QSymmS16
2393  };
2394 
2395  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2396  "Reference Resize: input type not supported");
2397 
2398  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2399  "Reference Resize: output type not supported");
2400 
2401  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2402  "Reference Resize: input and output types not matching");
2403 
2404  return supported;
2405 }
2406 
2407 bool RefLayerSupport::IsReverseV2Supported(const TensorInfo& input0,
2408  const TensorInfo& input1,
2409  const TensorInfo& output,
2410  Optional<std::string&> reasonIfUnsupported) const
2411 {
2412  bool supported = true;
2413  // ReverseV2 is data type agnostic so it can support all the types in the Reference backend
2414  std::array<DataType,8> supportedTypes =
2415  {
2416  DataType::BFloat16,
2417  DataType::Float32,
2418  DataType::Float16,
2419  DataType::QAsymmS8,
2420  DataType::QAsymmU8,
2421  DataType::QSymmS8,
2422  DataType::QSymmS16,
2423  DataType::Signed32
2424  };
2425 
2426  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2427  "Reference ReverseV2: input0 type not supported");
2428 
2429  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2430  "Reference ReverseV2: output type not supported");
2431 
2432  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2433  "Reference ReverseV2: input0 and output types not matching");
2434 
2435  std::array<DataType,6> input2SupportedTypes =
2436  {
2437  DataType::Signed32
2438  };
2439 
2440  supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
2441  "Reference ReverseV2: input1 type not supported");
2442 
2443  return supported;
2444 }
2445 
2446 bool RefLayerSupport::IsShapeSupported(const TensorInfo& input,
2447  const TensorInfo& output,
2448  Optional<std::string&> reasonIfUnsupported) const
2449 {
2450  IgnoreUnused(input);
2451  bool supported = true;
2452 
2453  std::array<DataType, 1> supportedTypes =
2454  {
2455  DataType::Signed32
2456  };
2457 
2458  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2459  "Reference Shape: output type not supported");
2460 
2461  return supported;
2462 }
2463 
2464 bool RefLayerSupport::IsSliceSupported(const TensorInfo& input,
2465  const TensorInfo& output,
2466  const SliceDescriptor& descriptor,
2467  Optional<std::string&> reasonIfUnsupported) const
2468 {
2469  IgnoreUnused(descriptor);
2470  bool supported = true;
2471 
2472  std::array<DataType, 5> supportedTypes =
2473  {
2474  DataType::Float32,
2475  DataType::QAsymmS8,
2476  DataType::QAsymmU8,
2477  DataType::QSymmS16,
2478  DataType::Signed32
2479  };
2480 
2481  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2482  "Reference Slice: input type not supported");
2483 
2484  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2485  "Reference Slice: output type not supported");
2486 
2487  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2488  "Reference Slice: input and output types are mismatched");
2489 
2490  return supported;
2491 }
2492 
2493 bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
2494  const TensorInfo& output,
2495  const SoftmaxDescriptor& descriptor,
2496  Optional<std::string&> reasonIfUnsupported) const
2497 {
2498  IgnoreUnused(descriptor);
2499  bool supported = true;
2500  std::array<DataType,7> supportedTypes =
2501  {
2502  DataType::Float32,
2503  DataType::Float16,
2504  DataType::QSymmS8,
2505  DataType::QAsymmS8,
2506  DataType::QAsymmU8,
2507  DataType::QSymmS16
2508  };
2509 
2510  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2511  "Reference Softmax: output type not supported");
2512 
2513  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2514  "Reference Softmax: input type not supported");
2515 
2516  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2517  "Reference Softmax: input type not supported");
2518 
2519  return supported;
2520 }
2521 
2522 bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
2523  const TensorInfo& output,
2524  const SpaceToBatchNdDescriptor& descriptor,
2525  Optional<std::string&> reasonIfUnsupported) const
2526 {
2527  IgnoreUnused(descriptor);
2528  bool supported = true;
2529  std::array<DataType,6> supportedTypes =
2530  {
2531  DataType::Float32,
2532  DataType::Float16,
2533  DataType::QAsymmS8,
2534  DataType::QAsymmU8,
2535  DataType::QSymmS16
2536  };
2537 
2538  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2539  "Reference SpaceToBatchNd: input type not supported");
2540 
2541  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2542  "Reference SpaceToBatchNd: output type not supported");
2543 
2544  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2545  "Reference SpaceToBatchNd: input and output types are mismatched");
2546 
2547  return supported;
2548 }
2549 
2550 bool RefLayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
2551  const TensorInfo& output,
2552  const SpaceToDepthDescriptor& descriptor,
2553  Optional<std::string&> reasonIfUnsupported) const
2554 {
2555 
2556  IgnoreUnused(descriptor);
2557  bool supported = true;
2558 
2559  std::array<DataType,6> supportedTypes =
2560  {
2561  DataType::Float32,
2562  DataType::Float16,
2563  DataType::QAsymmS8,
2564  DataType::QAsymmU8,
2565  DataType::QSymmS16
2566  };
2567 
2568  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2569  "Reference SpaceToDepth: input type not supported");
2570 
2571  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2572  "Reference SpaceToDepth: output type not supported");
2573 
2574  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2575  "Reference SpaceToDepth: input and output types are mismatched");
2576 
2577  return supported;
2578 }
2579 
2580 bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
2581  const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
2582  const ViewsDescriptor& descriptor,
2583  Optional<std::string&> reasonIfUnsupported) const
2584 {
2585  IgnoreUnused(descriptor);
2586  bool supported = true;
2587  std::array<DataType,6> supportedTypes =
2588  {
2589  DataType::Float32,
2590  DataType::Float16,
2591  DataType::QAsymmS8,
2592  DataType::QAsymmU8,
2593  DataType::QSymmS16
2594  };
2595 
2596  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2597  "Reference splitter: output type not supported");
2598  for (const TensorInfo& output : outputs)
2599  {
2600  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2601  "Reference splitter: input type not supported");
2602 
2603  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2604  "Reference splitter: input and output types mismatched.");
2605  }
2606 
2607  return supported;
2608 }
2609 
2610 bool RefLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
2611  const TensorInfo& output,
2612  const StackDescriptor& descriptor,
2613  Optional<std::string&> reasonIfUnsupported) const
2614 {
2615  IgnoreUnused(descriptor);
2616 
2617  bool supported = true;
2618  std::array<DataType,7> supportedTypes =
2619  {
2620  DataType::Float32,
2621  DataType::Float16,
2622  DataType::QAsymmS8,
2623  DataType::QAsymmU8,
2624  DataType::QSymmS16,
2625  DataType::Signed32
2626  };
2627 
2628  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2629  "Reference stack: output type not supported");
2630  for (const TensorInfo* input : inputs)
2631  {
2632  ARMNN_ASSERT(input != nullptr);
2633  supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
2634  "Reference stack: input type not supported");
2635 
2636  supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
2637  "Reference stack: input and output types mismatched.");
2638  }
2639 
2640  return supported;
2641 }
2642 
2643 bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
2644  const TensorInfo& output,
2645  const StridedSliceDescriptor& descriptor,
2646  Optional<std::string&> reasonIfUnsupported) const
2647 {
2648  IgnoreUnused(descriptor);
2649  bool supported = true;
2650 
2651  std::array<DataType,5> supportedTypes =
2652  {
2653  DataType::Float32,
2654  DataType::QAsymmS8,
2655  DataType::QAsymmU8,
2656  DataType::QSymmS16
2657  };
2658 
2659  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2660  "Reference StridedSlice: input type not supported");
2661 
2662  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2663  "Reference StridedSlice: output type not supported");
2664 
2665  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2666  "Reference StridedSlice: input and output types are mismatched");
2667 
2668  return supported;
2669 }
2670 
2671 bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
2672  const TensorInfo& input1,
2673  const TensorInfo& output,
2674  Optional<std::string&> reasonIfUnsupported) const
2675 {
2676  bool supported = true;
2677 
2678  std::array<DataType,7> supportedTypes = {
2679  DataType::Float32,
2680  DataType::Float16,
2681  DataType::QAsymmS8,
2682  DataType::QAsymmU8,
2683  DataType::QSymmS16,
2684  DataType::Signed32
2685  };
2686 
2687  supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2688  "Reference subtraction: input 0 is not a supported type.");
2689 
2690  supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2691  "Reference subtraction: input 1 is not a supported type.");
2692 
2693  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2694  "Reference subtraction: output is not a supported type.");
2695 
2696  supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2697  "Reference subtraction: input 0 and Input 1 types are mismatched");
2698 
2699  supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2700  "Reference subtraction: input and output types are mismatched");
2701 
2702  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2703  "Reference subtraction: shapes are not suitable for implicit broadcast.");
2704 
2705  return supported;
2706 }
2707 
2708 bool RefLayerSupport::IsPreluSupported(const TensorInfo& input,
2709  const TensorInfo& alpha,
2710  const TensorInfo& output,
2711  Optional<std::string&> reasonIfUnsupported) const
2712 {
2713  bool supported = true;
2714 
2715  std::array<DataType, 6> supportedTypes
2716  {
2717  DataType::Float32,
2718  DataType::Float16,
2719  DataType::QAsymmS8,
2720  DataType::QAsymmU8,
2721  DataType::QSymmS16
2722  };
2723 
2724  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2725  "PReLU: input is not a supported type.");
2726 
2727  supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
2728  "PReLU: alpha is not a supported type.");
2729 
2730  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2731  "PReLU: output is not a supported type.");
2732 
2733  supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
2734  "PReLU: input, alpha and output types are mismatched");
2735 
2736  supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
2737  "PReLU: shapes are not suitable for implicit broadcast");
2738 
2739  return supported;
2740 }
2741 
2742 bool RefLayerSupport::IsTileSupported(const TensorInfo& input,
2743  const TensorInfo& output,
2744  const TileDescriptor& descriptor,
2745  Optional<std::string&> reasonIfUnsupported) const
2746 {
2747  IgnoreUnused(descriptor);
2748 
2749  bool supported = true;
2750 
2751  std::array<DataType, 7> supportedTypes
2752  {
2753  DataType::Float32,
2754  DataType::Float16,
2755  DataType::QAsymmS8,
2756  DataType::QAsymmU8,
2757  DataType::QSymmS8,
2758  DataType::QSymmS16,
2759  DataType::Signed32
2760  };
2761 
2762  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2763  "Tile: input type not supported.");
2764 
2765  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2766  "Tile: output type not supported");
2767 
2768  return supported;
2769 }
2770 
2771 bool RefLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
2772  const TensorInfo& output,
2773  const TransposeConvolution2dDescriptor& descriptor,
2774  const TensorInfo& weights,
2775  const Optional<TensorInfo>& biases,
2776  Optional<std::string&> reasonIfUnsupported) const
2777 {
2778  IgnoreUnused(descriptor);
2779  bool supported = true;
2780 
2781  std::array<DataType,7> supportedTypes =
2782  {
2783  DataType::Float32,
2784  DataType::Float16,
2785  DataType::QAsymmS8,
2786  DataType::QAsymmU8,
2787  DataType::QSymmS8,
2788  DataType::QSymmS16
2789  };
2790 
2791  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2792  "Reference TransposeConvolution2d: input is not a supported type.");
2793 
2794  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2795  "Reference TransposeConvolution2d: output is not a supported type.");
2796 
2797  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2798  "Reference TransposeConvolution2d: input and output types mismatched.");
2799 
2800 
2801  const DataType inputType = input.GetDataType();
2802  if (IsQuantized8BitType(inputType))
2803  {
2804  std::array<DataType, 3> supportedWeightTypes =
2805  {
2806  DataType::QAsymmS8,
2807  DataType::QAsymmU8,
2808  DataType::QSymmS8
2809  };
2810 
2811  supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
2812  "Reference TransposeConvolution2d: weights type not supported for "
2813  "quantized input.");
2814  }
2815  else
2816  {
2817  supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
2818  "Reference TransposeConvolution2d: weights is not a supported type.");
2819 
2820  supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
2821  "Reference TransposeConvolution2d: input and weights types mismatched.");
2822  }
2823 
2824  if (biases.has_value())
2825  {
2826  std::array<DataType,4> biasesSupportedTypes =
2827  {
2828  DataType::Float32,
2829  DataType::Float16,
2830  DataType::Signed32
2831  };
2832  supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
2833  "Reference TransposeConvolution2d: biases is not a supported type.");
2834  }
2835 
2836  return supported;
2837 }
2838 
2839 bool RefLayerSupport::IsTransposeSupported(const TensorInfo& input,
2840  const TensorInfo& output,
2841  const TransposeDescriptor& descriptor,
2842  Optional<std::string&> reasonIfUnsupported) const
2843 {
2844  IgnoreUnused(descriptor);
2845  bool supported = true;
2846 
2847  // Define supported output and inputs types.
2848  std::array<DataType, 6> supportedTypes =
2849  {
2850  DataType::BFloat16,
2851  DataType::Float32,
2852  DataType::Float16,
2853  DataType::QAsymmS8,
2854  DataType::QAsymmU8,
2855  DataType::QSymmS16
2856  };
2857 
2858  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2859  "Reference transpose: input is not a supported type.");
2860 
2861  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2862  "Reference transpose: output is not a supported type.");
2863 
2864  supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2865  "Reference transpose: input and output types are mismatched.");
2866 
2867  return supported;
2868 }
2869 
2870 bool RefLayerSupport::IsUnidirectionalSequenceLstmSupported(
2871  const TensorInfo& input,
2872  const TensorInfo& outputStateIn,
2873  const TensorInfo& cellStateIn,
2874  const TensorInfo& outputStateOut,
2875  const TensorInfo& cellStateOut,
2876  const TensorInfo& output,
2877  const UnidirectionalSequenceLstmDescriptor& descriptor,
2878  const LstmInputParamsInfo& paramsInfo,
2879  Optional<std::string&> reasonIfUnsupported) const
2880 {
2881  IgnoreUnused(descriptor);
2882  IgnoreUnused(paramsInfo);
2883  IgnoreUnused(outputStateIn);
2884  IgnoreUnused(cellStateIn);
2885  IgnoreUnused(outputStateOut);
2886  IgnoreUnused(cellStateOut);
2887  bool supported = true;
2888 
2889  std::array<DataType, 2> supportedTypes =
2890  {
2891  DataType::Float32,
2892  DataType::QAsymmS8
2893  };
2894 
2895  std::array<DataType, 2> supportedWeightTypes =
2896  {
2897  DataType::Float32,
2898  DataType::QAsymmS8
2899  };
2900 
2901  std::array<DataType, 3> supportedBiasTypes =
2902  {
2903  DataType::Float32,
2904  DataType::QAsymmS8,
2905  DataType::Signed32
2906  };
2907 
2908  // check inputs and outputs
2909  supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2910  "Reference UnidirectionalSequenceLstm: input is not a supported type.");
2911  supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2912  "Reference UnidirectionalSequenceLstm: output is not a supported type.");
2913 
2914  // check layer parameters
2915  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
2916  reasonIfUnsupported,
2917  "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
2918  "is not a supported type.");
2919  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
2920  reasonIfUnsupported,
2921  "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
2922  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
2923  reasonIfUnsupported,
2924  "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
2925  "is not a supported type.");
2926  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
2927  reasonIfUnsupported,
2928  "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
2929  "is not a supported type.");
2930  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
2931  reasonIfUnsupported,
2932  "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
2933  "is not a supported type.");
2934  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
2935  reasonIfUnsupported,
2936  "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
2937  "is not a supported type.");
2938 
2939  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetGateBias(), supportedBiasTypes), reasonIfUnsupported,
2940  "Reference UnidirectionalSequenceLstm: ForgetGateBias is not a supported type.");
2941  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellBias(), supportedBiasTypes), reasonIfUnsupported,
2942  "Reference UnidirectionalSequenceLstm: CellBias is not a supported type.");
2943  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputGateBias(), supportedBiasTypes), reasonIfUnsupported,
2944  "Reference UnidirectionalSequenceLstm: OutputGateBias is not a supported type.");
2945  if (!descriptor.m_CifgEnabled)
2946  {
2947  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
2948  reasonIfUnsupported,
2949  "Reference UnidirectionalSequenceLstm: InputToInputWeights "
2950  "is not a supported type.");
2951  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
2952  reasonIfUnsupported,
2953  "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
2954  "is not a supported type.");
2955  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputGateBias(), supportedBiasTypes), reasonIfUnsupported,
2956  "Reference UnidirectionalSequenceLstm: InputGateBias is not a supported type.");
2957  if (descriptor.m_PeepholeEnabled)
2958  {
2959  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
2960  reasonIfUnsupported,
2961  "Reference UnidirectionalSequenceLstm: CellToInputWeights "
2962  "is not a supported type.");
2963  }
2964  }
2965  if (descriptor.m_PeepholeEnabled)
2966  {
2967  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
2968  reasonIfUnsupported,
2969  "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
2970  "is not a supported type.");
2971  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
2972  reasonIfUnsupported,
2973  "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
2974  "is not a supported type.");
2975  }
2976  if (descriptor.m_ProjectionEnabled)
2977  {
2978  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
2979  reasonIfUnsupported,
2980  "Reference UnidirectionalSequenceLstm: ProjectionWeights "
2981  "is not a supported type.");
2982  if (paramsInfo.m_ProjectionBias != nullptr)
2983  {
2984  supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
2985  "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
2986  "are mismatched");
2987  }
2988  }
2989  if (descriptor.m_LayerNormEnabled)
2990  {
2991  if (!descriptor.m_CifgEnabled)
2992  {
2993  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
2994  reasonIfUnsupported,
2995  "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
2996  "is not a supported type.");
2997  }
2998  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
2999  reasonIfUnsupported,
3000  "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
3001  "is not a supported type.");
3002  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
3003  reasonIfUnsupported,
3004  "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
3005  "is not a supported type.");
3006  supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
3007  reasonIfUnsupported,
3008  "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
3009  "is not a supported type.");
3010  }
3011 
3012  return supported;
3013 }
3014 
3015 } // namespace armnn
armnn::RefLayerSupport::IsLstmSupported
bool IsLstmSupported(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, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1777
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:828
armnn::LayerType::SpaceToDepth
@ SpaceToDepth
armnn::RefLayerSupport::IsDepthwiseConvolutionSupported
bool IsDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1226
armnn::DataType::Boolean
@ Boolean
armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:244
armnn::LayerType::Permute
@ Permute
armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:36
armnn::LstmInputParamsInfo::GetCellBias
const TensorInfo & GetCellBias() const
Definition: LstmParams.hpp:173
armnn::RefLayerSupport::IsPooling3dSupported
bool IsPooling3dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling3dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2219
armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:507
armnn::LayerType::Splitter
@ Splitter
armnn::RefLayerSupport::IsReverseV2Supported
bool IsReverseV2Supported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2407
armnn::LayerType::BatchNormalization
@ BatchNormalization
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1380
armnn::Optional
Definition: Optional.hpp:270
armnn::RefLayerSupport::IsQLstmSupported
bool IsQLstmSupported(const TensorInfo &input, const TensorInfo &previousOutputIn, const TensorInfo &previousCellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const QLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2250
armnn::IsQuantized8BitType
constexpr bool IsQuantized8BitType(DataType dataType)
Definition: TypesUtils.hpp:316
armnn::ActivationFunction::LeakyReLu
@ LeakyReLu
armnn::RefLayerSupport::IsTileSupported
bool IsTileSupported(const TensorInfo &input, const TensorInfo &output, const TileDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2742
armnn::LstmInputParamsInfo::GetInputToCellWeights
const TensorInfo & GetInputToCellWeights() const
Definition: LstmParams.hpp:129
armnn::Pooling3dDescriptor
A Pooling3dDescriptor for the Pooling3dLayer.
Definition: Descriptors.hpp:431
armnn::RefLayerSupport::IsConvolution2dSupported
bool IsConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1030
armnn::RefLayerSupport::IsFloorSupported
bool IsFloorSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1503
armnn::BiasAndWeightsTypesMatch
Definition: LayerSupportRules.hpp:118
armnn::RefLayerSupport::IsDequantizeSupported
bool IsDequantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1295
armnn::ActivationFunction::SoftReLu
@ SoftReLu
armnn::Rule
Definition: LayerSupportRules.hpp:48
armnn::RefLayerSupport::IsPooling2dSupported
bool IsPooling2dSupported(const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2189
armnn::ResizeDescriptor
A ResizeDescriptor for the ResizeLayer.
Definition: Descriptors.hpp:985
armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:67
armnn::RefLayerSupport::IsLayerSupported
bool IsLayerSupported(const LayerType &type, const std::vector< TensorInfo > &infos, const BaseDescriptor &descriptor, const Optional< LstmInputParamsInfo > &lstmParamsInfo, const Optional< QuantizedLstmInputParamsInfo > &, Optional< std::string & > reasonIfUnsupported) const override
Default implementation of the ILayerSupport interface, Backends should implement this as a switch sta...
Definition: RefLayerSupport.cpp:61
armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:847
armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:965
armnn::RefLayerSupport::IsDetectionPostProcessSupported
bool IsDetectionPostProcessSupported(const TensorInfo &boxEncodings, const TensorInfo &scores, const TensorInfo &anchors, const TensorInfo &detectionBoxes, const TensorInfo &detectionClasses, const TensorInfo &detectionScores, const TensorInfo &numDetections, const DetectionPostProcessDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1330
TypesUtils.hpp
armnn::LayerType::InstanceNormalization
@ InstanceNormalization
armnn::LayerType::ConvertFp16ToFp32
@ ConvertFp16ToFp32
armnn::ActivationFunction::Sqrt
@ Sqrt
armnn::TensorInfo
Definition: Tensor.hpp:152
armnn::LayerType::Floor
@ Floor
armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:809
armnn::RefLayerSupport::IsAdditionSupported
bool IsAdditionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:621
armnn::RefLayerSupport::IsInputSupported
bool IsInputSupported(const TensorInfo &input, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1655
armnn::LayerType::Transpose
@ Transpose
armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:769
armnn::LayerType::Comparison
@ Comparison
armnn::RefLayerSupport::IsMeanSupported
bool IsMeanSupported(const TensorInfo &input, const TensorInfo &output, const MeanDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1925
armnn::TensorInfo::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:197
armnn::RefLayerSupport::IsTransposeConvolution2dSupported
bool IsTransposeConvolution2dSupported(const TensorInfo &input, const TensorInfo &output, const TransposeConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2771
armnn::LstmInputParamsInfo::GetProjectionBias
const TensorInfo & GetProjectionBias() const
Definition: LstmParams.hpp:185
armnn::LayerType::StridedSlice
@ StridedSlice
armnn::ChannelShuffleDescriptor
A ChannelShuffleDescriptor for the ChannelShuffle operator.
Definition: Descriptors.hpp:1562
armnn::DataType::Float32
@ Float32
armnn::ActivationFunction::TanH
@ TanH
armnn::LstmInputParamsInfo::GetInputGateBias
const TensorInfo & GetInputGateBias() const
Definition: LstmParams.hpp:165
armnn::LayerType::Tile
@ Tile
armnn::RefLayerSupport::IsRankSupported
bool IsRankSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2309
armnn::DataType::QAsymmU8
@ QAsymmU8
armnn::ActivationFunction::BoundedReLu
@ BoundedReLu
min(a, max(b, input)) ReLu1 & ReLu6.
armnn::LayerType::Stack
@ Stack
armnn::DataType::QSymmS8
@ QSymmS8
armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1251
armnn::LstmInputParamsInfo::GetRecurrentToInputWeights
const TensorInfo & GetRecurrentToInputWeights() const
Definition: LstmParams.hpp:137
armnn::LstmInputParamsInfo::GetRecurrentToForgetWeights
const TensorInfo & GetRecurrentToForgetWeights() const
Definition: LstmParams.hpp:141
IgnoreUnused.hpp
armnn::LayerType::Normalization
@ Normalization
RefLayerSupport.hpp
armnn::LayerType::QuantizedLstm
@ QuantizedLstm
armnn::LayerType::Reduce
@ Reduce
armnn::RefLayerSupport::IsSplitterSupported
bool IsSplitterSupported(const TensorInfo &input, const std::vector< std::reference_wrapper< TensorInfo >> &outputs, const ViewsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2580
armnn::RefLayerSupport::IsConvolution3dSupported
bool IsConvolution3dSupported(const TensorInfo &input, const TensorInfo &output, const Convolution3dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1099
armnn::LayerType::ElementwiseUnary
@ ElementwiseUnary
armnn::RefLayerSupport::IsBatchMatMulSupported
bool IsBatchMatMulSupported(const TensorInfo &inputX, const TensorInfo &inputY, const TensorInfo &output, const BatchMatMulDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:690
armnn::LstmInputParamsInfo::GetRecurrentToCellWeights
const TensorInfo & GetRecurrentToCellWeights() const
Definition: LstmParams.hpp:145
armnn::ActivationFunction::HardSwish
@ HardSwish
armnn::DataType::QSymmS16
@ QSymmS16
armnn::ActivationFunction::Gelu
@ Gelu
armnn::RefLayerSupport::IsSubtractionSupported
bool IsSubtractionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2671
armnn::LayerType::GatherNd
@ GatherNd
armnn::LayerType::ElementwiseBinary
@ ElementwiseBinary
armnn::RefLayerSupport::IsQuantizeSupported
bool IsQuantizeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2274
NumericCast.hpp
armnn::DataType::BFloat16
@ BFloat16
armnn::RefLayerSupport::IsArgMinMaxSupported
bool IsArgMinMaxSupported(const TensorInfo &input, const TensorInfo &output, const ArgMinMaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:658
armnn::ShapesAreSameRank
Definition: LayerSupportRules.hpp:138
armnn::LayerType::ConvertFp32ToFp16
@ ConvertFp32ToFp16
armnn::RefLayerSupport::IsPermuteSupported
bool IsPermuteSupported(const TensorInfo &input, const TensorInfo &output, const PermuteDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2158
armnn::MeanDescriptor::m_KeepDims
bool m_KeepDims
Enable/disable keep dimensions. If true, then the reduced dimensions that are of length 1 are kept.
Definition: Descriptors.hpp:1192
armnn::RefLayerSupport::IsComparisonSupported
bool IsComparisonSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const ComparisonDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:908
LayerSupportCommon.hpp
armnn::RefLayerSupport::IsBatchNormalizationSupported
bool IsBatchNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &mean, const TensorInfo &var, const TensorInfo &beta, const TensorInfo &gamma, const BatchNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:735
armnn::LstmInputParamsInfo::GetInputLayerNormWeights
const TensorInfo & GetInputLayerNormWeights() const
Definition: LstmParams.hpp:189
armnn::TypeNotPerAxisQuantized
Definition: LayerSupportRules.hpp:110
armnn::LayerType::Slice
@ Slice
armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1148
armnn::RefLayerSupport::IsDilatedDepthwiseConvolutionSupported
bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo &input, const TensorInfo &output, const DepthwiseConvolution2dDescriptor &descriptor, const TensorInfo &weights, const Optional< TensorInfo > &biases, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1362
armnn::RefLayerSupport::IsSpaceToDepthSupported
bool IsSpaceToDepthSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToDepthDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2550
armnn::RefLayerSupport::IsActivationSupported
bool IsActivationSupported(const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:553
armnn::DataType::Float16
@ Float16
armnn::RefLayerSupport::IsFakeQuantizationSupported
bool IsFakeQuantizationSupported(const TensorInfo &input, const FakeQuantizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1460
armnn::LayerType::ChannelShuffle
@ ChannelShuffle
armnn::LayerSupportBase::IsQuantizedLstmSupported
bool IsQuantizedLstmSupported(const TensorInfo &input, const TensorInfo &previousCellStateIn, const TensorInfo &previousOutputIn, const TensorInfo &cellStateOut, const TensorInfo &output, const QuantizedLstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:120
armnn::RefLayerSupport::IsElementwiseUnarySupported
bool IsElementwiseUnarySupported(const TensorInfo &input, const TensorInfo &output, const ElementwiseUnaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1409
armnn::RefLayerSupport::IsConcatSupported
bool IsConcatSupported(const std::vector< const TensorInfo * > inputs, const TensorInfo &output, const OriginsDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:939
armnn::LstmInputParamsInfo::GetCellToInputWeights
const TensorInfo & GetCellToInputWeights() const
Definition: LstmParams.hpp:153
armnn::LstmInputParamsInfo::GetRecurrentToOutputWeights
const TensorInfo & GetRecurrentToOutputWeights() const
Definition: LstmParams.hpp:149
armnn::UnaryOperation::LogicalNot
@ LogicalNot
armnn::ShapesAreBroadcastCompatible
Definition: LayerSupportRules.hpp:154
armnn::LstmInputParamsInfo::GetInputToInputWeights
const TensorInfo & GetInputToInputWeights() const
Definition: LstmParams.hpp:121
armnn::RefLayerSupport::IsReduceSupported
bool IsReduceSupported(const TensorInfo &input, const TensorInfo &output, const ReduceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2324
armnn::LayerType::Subtraction
@ Subtraction
armnn::LayerType::Prelu
@ Prelu
armnn::FullyConnectedDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:526
armnn::LayerType::LogicalBinary
@ LogicalBinary
armnn::LayerType::Concat
@ Concat
armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:1196
armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1490
armnn::RefLayerSupport::IsResizeSupported
bool IsResizeSupported(const TensorInfo &input, const TensorInfo &output, const ResizeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2377
armnn::RefLayerSupport::IsDepthToSpaceSupported
bool IsDepthToSpaceSupported(const TensorInfo &input, const TensorInfo &output, const DepthToSpaceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1197
armnn::LayerType::TransposeConvolution2d
@ TransposeConvolution2d
armnn::LayerType::Merge
@ Merge
PolymorphicDowncast.hpp
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1228
armnn::DataType
DataType
Definition: Types.hpp:48
armnn::LayerType::Debug
@ Debug
armnn::LayerType::Softmax
@ Softmax
armnn::RefLayerSupport::IsBatchToSpaceNdSupported
bool IsBatchToSpaceNdSupported(const TensorInfo &input, const TensorInfo &output, const BatchToSpaceNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:781
armnn::RefLayerSupport::IsBroadcastToSupported
bool IsBroadcastToSupported(const TensorInfo &input, const TensorInfo &output, const BroadcastToDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:816
armnn::ActivationFunction::Elu
@ Elu
armnn::RefLayerSupport::IsSpaceToBatchNdSupported
bool IsSpaceToBatchNdSupported(const TensorInfo &input, const TensorInfo &output, const SpaceToBatchNdDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2522
armnn::TensorNumDimensionsAreCorrect
Definition: LayerSupportRules.hpp:181
armnn::LstmInputParamsInfo::GetForgetGateBias
const TensorInfo & GetForgetGateBias() const
Definition: LstmParams.hpp:169
armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:1023
armnn::LayerSupportBase::IsMergeSupported
bool IsMergeSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:112
armnn::RefLayerSupport::IsL2NormalizationSupported
bool IsL2NormalizationSupported(const TensorInfo &input, const TensorInfo &output, const L2NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1692
armnn::InvalidArgumentException
Definition: Exceptions.hpp:80
armnn::LayerType::Quantize
@ Quantize
armnn::RefLayerSupport::IsMaximumSupported
bool IsMaximumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1888
armnn::LstmInputParamsInfo::GetCellToForgetWeights
const TensorInfo & GetCellToForgetWeights() const
Definition: LstmParams.hpp:157
armnn::ActivationFunction::Linear
@ Linear
armnn::LayerSupportBase::IsMemImportSupported
bool IsMemImportSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: LayerSupportBase.cpp:105
armnn::ActivationDescriptor::m_Function
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu,...
Definition: Descriptors.hpp:59
armnn::LayerType::Multiplication
@ Multiplication
armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:149
armnn::BatchMatMulDescriptor
A BatchMatMulDescriptor for the BatchMatMul operator.
Definition: Descriptors.hpp:1584
armnn::LayerType::Addition
@ Addition
armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:1043
armnn::RefLayerSupport::IsReshapeSupported
bool IsReshapeSupported(const TensorInfo &input, const TensorInfo &output, const ReshapeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2353
armnn::Convolution3dDescriptor
A Convolution3dDescriptor for the Convolution3dLayer.
Definition: Descriptors.hpp:588
armnn::LayerType::DepthToSpace
@ DepthToSpace
armnn::LayerType::BroadcastTo
@ BroadcastTo
armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22
armnn::RefLayerSupport::IsCastSupported
bool IsCastSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:846
armnn::RefLayerSupport::IsFullyConnectedSupported
bool IsFullyConnectedSupported(const TensorInfo &input, const TensorInfo &output, const TensorInfo &weights, const TensorInfo &biases, const FullyConnectedDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1525
armnn::LayerType::DetectionPostProcess
@ DetectionPostProcess
armnn::LayerType::MemImport
@ MemImport
armnn::LayerType::Pooling2d
@ Pooling2d
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:200
armnn::LayerType::Division
@ Division
armnn::TypeIs
Definition: LayerSupportRules.hpp:102
armnn::DataType::Signed32
@ Signed32
armnn::LayerType::Shape
@ Shape
armnn::RefLayerSupport::IsOutputSupported
bool IsOutputSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2122
armnn::RefLayerSupport::IsDebugSupported
bool IsDebugSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1167
armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:875
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:534
armnn::ActivationFunction::Abs
@ Abs
armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:89
armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:925
armnn::RefLayerSupport::IsConvertFp16ToFp32Supported
bool IsConvertFp16ToFp32Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:990
armnn::DataType::QAsymmS8
@ QAsymmS8
armnn::ElementwiseUnaryDescriptor::m_Operation
UnaryOperation m_Operation
Specifies the elementwiseUnary operation to execute.
Definition: Descriptors.hpp:145
armnn::LayerType::FullyConnected
@ FullyConnected
armnn::LayerType::Gather
@ Gather
armnn::RefLayerSupport::IsLogicalBinarySupported
bool IsLogicalBinarySupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const LogicalBinaryDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1726
armnn::LayerType::Pooling3d
@ Pooling3d
armnn::RefLayerSupport::IsDivisionSupported
bool IsDivisionSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1372
armnn::BiasAndWeightsTypesCompatible
Definition: LayerSupportRules.hpp:126
armnn::LayerType::LogSoftmax
@ LogSoftmax
armnn::LayerType::BatchMatMul
@ BatchMatMul
armnn::LayerType::DepthwiseConvolution2d
@ DepthwiseConvolution2d
armnn::RefLayerSupport::IsNormalizationSupported
bool IsNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const NormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2090
armnn::LayerType::Cast
@ Cast
armnn::LayerType::BatchToSpaceNd
@ BatchToSpaceNd
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:1102
armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1303
armnn::MeanDescriptor::m_Axis
std::vector< unsigned int > m_Axis
Values for the dimensions to reduce.
Definition: Descriptors.hpp:1190
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::RefLayerSupport::IsPreluSupported
bool IsPreluSupported(const TensorInfo &input, const TensorInfo &alpha, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2708
armnn::RefLayerSupport::IsFillSupported
bool IsFillSupported(const TensorInfo &input, const TensorInfo &output, const FillDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1478
armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1518
armnn::LayerType::Reshape
@ Reshape
armnn::LayerType::SpaceToBatchNd
@ SpaceToBatchNd
armnn::LstmInputParamsInfo::GetOutputGateBias
const TensorInfo & GetOutputGateBias() const
Definition: LstmParams.hpp:177
armnn::LayerType::Fill
@ Fill
armnn::LayerType::L2Normalization
@ L2Normalization
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::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::RefLayerSupport::IsMultiplicationSupported
bool IsMultiplicationSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2053
armnn::LayerType::Minimum
@ Minimum
armnn::IsSupportedForDataTypeGeneric
bool IsSupportedForDataTypeGeneric(Optional< std::string & > reasonIfUnsupported, DataType dataType, Float16Func float16FuncPtr, Float32Func float32FuncPtr, Uint8Func uint8FuncPtr, Int32Func int32FuncPtr, BooleanFunc booleanFuncPtr, Params &&... params)
Definition: LayerSupportCommon.hpp:27
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
armnn::RefLayerSupport::IsStridedSliceSupported
bool IsStridedSliceSupported(const TensorInfo &input, const TensorInfo &output, const StridedSliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2643
armnn::LayerType::Map
@ Map
armnn::LayerType::ReverseV2
@ ReverseV2
armnn::RefLayerSupport::IsMemCopySupported
bool IsMemCopySupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1987
armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:201
armnn::LstmInputParamsInfo::GetOutputLayerNormWeights
const TensorInfo & GetOutputLayerNormWeights() const
Definition: LstmParams.hpp:201
armnn::ActivationFunction::ReLu
@ ReLu
armnn::LayerType::MemCopy
@ MemCopy
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
armnn::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:129
armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1440
Types.hpp
armnn::LayerType::ArgMinMax
@ ArgMinMax
armnn::LayerType::Pad
@ Pad
armnn::RefLayerSupport::IsConstantSupported
bool IsConstantSupported(const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:972
armnn::TypesAreEqual
Definition: LayerSupportRules.hpp:72
armnn::LstmInputParamsInfo
Definition: LstmParams.hpp:63
armnn::LayerType::Rank
@ Rank
armnn::RefLayerSupport::IsChannelShuffleSupported
bool IsChannelShuffleSupported(const TensorInfo &input, const TensorInfo &output, const ChannelShuffleDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:876
armnn::LayerType::Mean
@ Mean
armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1150
armnn::RefLayerSupport::IsShapeSupported
bool IsShapeSupported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2446
armnn::ActivationFunction::Square
@ Square
armnn::RefLayerSupport::IsTransposeSupported
bool IsTransposeSupported(const TensorInfo &input, const TensorInfo &output, const TransposeDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2839
armnn::LayerType::Input
@ Input
armnn::LayerType::Resize
@ Resize
armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:713
armnn::RefLayerSupport::IsConvertFp32ToFp16Supported
bool IsConvertFp32ToFp16Supported(const TensorInfo &input, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1010
armnn::RefLayerSupport::IsGatherSupported
bool IsGatherSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, const GatherDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1622
armnn::LstmInputParamsInfo::GetProjectionWeights
const TensorInfo & GetProjectionWeights() const
Definition: LstmParams.hpp:181
LayerSupportRules.hpp
armnn::RefLayerSupport::IsStackSupported
bool IsStackSupported(const std::vector< const TensorInfo * > &inputs, const TensorInfo &output, const StackDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2610
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string & > reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:38
armnn::DataType::Signed64
@ Signed64
armnn::RefLayerSupport::IsLogSoftmaxSupported
bool IsLogSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const LogSoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported) const
Definition: RefLayerSupport.cpp:1751
armnn::LayerType::Convolution2d
@ Convolution2d
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:371
armnn::LayerType::FakeQuantization
@ FakeQuantization
armnn::LayerType::Maximum
@ Maximum
armnn::BroadcastToDescriptor
Definition: Descriptors.hpp:1659
armnn::LayerType::Activation
@ Activation
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:659
armnn::TypeAnyOf
Definition: LayerSupportRules.hpp:90
armnn::LayerType::Lstm
@ Lstm
armnn::LayerType::Dequantize
@ Dequantize
armnn::LayerType::Convolution3d
@ Convolution3d
armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1538
armnn::RefLayerSupport::IsSoftmaxSupported
bool IsSoftmaxSupported(const TensorInfo &input, const TensorInfo &output, const SoftmaxDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2493
armnn::FakeQuantizationDescriptor
A FakeQuantizationDescriptor for the FakeQuantizationLayer.
Definition: Descriptors.hpp:906
armnn::LstmInputParamsInfo::m_ProjectionBias
const TensorInfo * m_ProjectionBias
Definition: LstmParams.hpp:105
armnn::RefLayerSupport::IsSliceSupported
bool IsSliceSupported(const TensorInfo &input, const TensorInfo &output, const SliceDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2464
armnn::LayerType
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below.
Definition: Types.hpp:491
armnn::LayerType::Unmap
@ Unmap
armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:1172
armnn::LstmInputParamsInfo::GetForgetLayerNormWeights
const TensorInfo & GetForgetLayerNormWeights() const
Definition: LstmParams.hpp:193
armnn::RefLayerSupport::IsPadSupported
bool IsPadSupported(const TensorInfo &input, const TensorInfo &output, const PadDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2128
armnn::LayerType::QLstm
@ QLstm
armnn::OptionalReferenceSwitch< std::is_reference< T >::value, T >::value
const T & value() const
Definition: Optional.hpp:146
armnn::RefLayerSupport::IsGatherNdSupported
bool IsGatherNdSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1591
armnn::TileDescriptor
Definition: Descriptors.hpp:1640
armnn::RefLayerSupport::IsUnidirectionalSequenceLstmSupported
bool IsUnidirectionalSequenceLstmSupported(const TensorInfo &input, const TensorInfo &outputStateIn, const TensorInfo &cellStateIn, const TensorInfo &outputStateOut, const TensorInfo &cellStateOut, const TensorInfo &output, const UnidirectionalSequenceLstmDescriptor &descriptor, const LstmInputParamsInfo &paramsInfo, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2870
armnn::RefLayerSupport::IsInstanceNormalizationSupported
bool IsInstanceNormalizationSupported(const TensorInfo &input, const TensorInfo &output, const InstanceNormalizationDescriptor &descriptor, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:1661
armnn::LstmInputParamsInfo::GetCellLayerNormWeights
const TensorInfo & GetCellLayerNormWeights() const
Definition: LstmParams.hpp:197
armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:177
armnn::ShapesAreSameTotalSize
Definition: LayerSupportRules.hpp:146
armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:1075
armnn::OptionalBase::has_value
bool has_value() const noexcept
Definition: Optional.hpp:53
armnn::TensorNumDimensionsAreGreaterOrEqualTo
Definition: LayerSupportRules.hpp:189
armnn::RefLayerSupport::IsMinimumSupported
bool IsMinimumSupported(const TensorInfo &input0, const TensorInfo &input1, const TensorInfo &output, Optional< std::string & > reasonIfUnsupported=EmptyOptional()) const
Definition: RefLayerSupport.cpp:2016
armnn::LayerType::Output
@ Output
armnn::LayerType::Constant
@ Constant
armnn::LstmInputParamsInfo::GetInputToForgetWeights
const TensorInfo & GetInputToForgetWeights() const
Definition: LstmParams.hpp:125
armnn::ActivationFunction::Sigmoid
@ Sigmoid