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