20 #include <boost/iterator/transform_iterator.hpp> 30 const TensorInfo OverrideDataType(
const TensorInfo& info, Optional<DataType> type)
37 return TensorInfo(info.GetShape(), type.value(), info.GetQuantizationScale(), info.GetQuantizationOffset());
45 std::string& outReasonIfUnsupported)
49 const Layer& layer = *(PolymorphicDowncast<const Layer*>(&connectableLayer));
52 if (!backendRegistry.IsBackendRegistered(backendId))
55 ss << connectableLayer.
GetName() <<
" is not supported on " << backendId
56 <<
" because this backend is not registered.";
58 outReasonIfUnsupported = ss.str();
62 auto backendFactory = backendRegistry.GetFactory(backendId);
63 auto backendObject = backendFactory();
64 auto layerSupportObject = backendObject->GetLayerSupport();
70 auto cLayer = PolymorphicDowncast<const ActivationLayer*>(&layer);
73 result = layerSupportObject->IsActivationSupported(
74 OverrideDataType(input, dataType),
75 OverrideDataType(output, dataType),
76 cLayer->GetParameters(),
85 result = layerSupportObject->IsAdditionSupported(
86 OverrideDataType(input0, dataType),
87 OverrideDataType(input1, dataType),
88 OverrideDataType(output, dataType),
94 auto cLayer = PolymorphicDowncast<const ArgMinMaxLayer*>(&layer);
99 result = layerSupportObject->IsArgMinMaxSupported(
100 OverrideDataType(input, dataType),
108 auto cLayer = PolymorphicDowncast<const BatchNormalizationLayer*>(&layer);
111 const TensorInfo& mean = cLayer->m_Mean->GetTensorInfo();
112 const TensorInfo& var = cLayer->m_Variance->GetTensorInfo();
113 const TensorInfo& beta = cLayer->m_Beta->GetTensorInfo();
114 const TensorInfo& gamma = cLayer->m_Gamma->GetTensorInfo();
115 result = layerSupportObject->IsBatchNormalizationSupported(
116 OverrideDataType(input, dataType),
117 OverrideDataType(output, dataType),
118 OverrideDataType(mean, dataType),
119 OverrideDataType(var, dataType),
120 OverrideDataType(beta, dataType),
121 OverrideDataType(gamma, dataType),
122 cLayer->GetParameters(),
130 auto cLayer = PolymorphicDowncast<const BatchToSpaceNdLayer*>(&layer);
132 result = layerSupportObject->IsBatchToSpaceNdSupported(OverrideDataType(input, dataType),
133 OverrideDataType(output, dataType),
134 cLayer->GetParameters(),
140 auto cLayer = PolymorphicDowncast<const ComparisonLayer*>(&layer);
146 result = layerSupportObject->IsComparisonSupported(OverrideDataType(input0, dataType),
147 OverrideDataType(input1, dataType),
149 cLayer->GetParameters(),
156 result = layerSupportObject->IsConstantSupported(OverrideDataType(output, dataType), reason);
163 result = layerSupportObject->IsConvertBf16ToFp32Supported(input, output, reason);
170 result = layerSupportObject->IsConvertFp16ToFp32Supported(input, output, reason);
177 result = layerSupportObject->IsConvertFp32ToBf16Supported(input, output, reason);
184 result = layerSupportObject->IsConvertFp32ToFp16Supported(input, output, reason);
189 auto cLayer = PolymorphicDowncast<const Convolution2dLayer*>(&layer);
200 if (descriptor.m_BiasEnabled)
206 result = layerSupportObject->IsConvolution2dSupported(
210 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
220 result = layerSupportObject->IsDebugSupported(OverrideDataType(input, dataType),
221 OverrideDataType(output, dataType),
227 auto cLayer = PolymorphicDowncast<const DepthToSpaceLayer*>(&layer);
232 result = layerSupportObject->IsDepthToSpaceSupported(OverrideDataType(input, dataType),
233 OverrideDataType(output, dataType),
234 cLayer->GetParameters(),
240 auto cLayer = PolymorphicDowncast<const DepthwiseConvolution2dLayer*>(&layer);
250 if (descriptor.m_BiasEnabled)
256 result = layerSupportObject->IsDepthwiseConvolutionSupported(
260 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
270 result = layerSupportObject->IsDequantizeSupported(input,
271 OverrideDataType(output, dataType),
277 auto cLayer = PolymorphicDowncast<const DetectionPostProcessLayer*>(&layer);
288 result = layerSupportObject->IsDetectionPostProcessSupported(boxEncodings,
301 auto cLayer = PolymorphicDowncast<const ElementwiseUnaryLayer*>(&layer);
306 result = layerSupportObject->IsElementwiseUnarySupported(OverrideDataType(input, dataType),
307 OverrideDataType(output, dataType),
308 cLayer->GetParameters(),
314 auto cLayer = PolymorphicDowncast<const FillLayer*>(&layer);
319 result = layerSupportObject->IsFillSupported(
320 OverrideDataType(input, dataType),
321 OverrideDataType(output, dataType),
328 auto cLayer = PolymorphicDowncast<const FakeQuantizationLayer*>(&layer);
330 result = layerSupportObject->IsFakeQuantizationSupported(OverrideDataType(input, dataType),
331 cLayer->GetParameters(),
339 result = layerSupportObject->IsFloorSupported(OverrideDataType(input, dataType),
340 OverrideDataType(output, dataType),
346 auto cLayer = PolymorphicDowncast<const FullyConnectedLayer*>(&layer);
363 biasInfoPtr = &biasInfo;
368 switch(input.GetDataType())
372 biasInfoPtr = &dummyBFloat16Bias;
377 biasInfoPtr = &dummyFloat16Bias;
382 biasInfoPtr = &dummyFloat32Bias;
390 biasInfoPtr = &dummyQA8Bias;
400 result = layerSupportObject->IsFullyConnectedSupported(
401 OverrideDataType(input, dataType),
402 OverrideDataType(output, dataType),
403 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
414 auto cLayer = PolymorphicDowncast<const GatherLayer*>(&layer);
416 result = layerSupportObject->IsGatherSupported(OverrideDataType(input0, dataType),
418 OverrideDataType(output, dataType),
426 result = layerSupportObject->IsInputSupported(OverrideDataType(input, dataType), reason);
431 auto cLayer = PolymorphicDowncast<const InstanceNormalizationLayer*>(&layer);
437 result = layerSupportObject->IsInstanceNormalizationSupported(
438 OverrideDataType(input, dataType),
439 OverrideDataType(output, dataType),
446 auto cLayer = PolymorphicDowncast<const L2NormalizationLayer*>(&layer);
452 result = layerSupportObject->IsL2NormalizationSupported(
453 OverrideDataType(input, dataType),
454 OverrideDataType(output, dataType),
461 auto cLayer = PolymorphicDowncast<const LogSoftmaxLayer*>(&layer);
466 result = layerSupportObject->IsLogSoftmaxSupported(OverrideDataType(input, dataType),
467 OverrideDataType(output, dataType),
468 cLayer->GetParameters(),
474 auto cLayer = PolymorphicDowncast<const LstmLayer*>(&layer);
492 = OverrideDataType(cLayer->m_BasicParameters.m_InputToForgetWeights->GetTensorInfo(), dataType);
494 = OverrideDataType(cLayer->m_BasicParameters.m_InputToCellWeights->GetTensorInfo(), dataType);
496 = OverrideDataType(cLayer->m_BasicParameters.m_InputToOutputWeights->GetTensorInfo(), dataType);
498 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToForgetWeights->GetTensorInfo(), dataType);
500 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToCellWeights->GetTensorInfo(), dataType);
502 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToOutputWeights->GetTensorInfo(), dataType);
504 = OverrideDataType(cLayer->m_BasicParameters.m_ForgetGateBias->GetTensorInfo(), dataType);
506 = OverrideDataType(cLayer->m_BasicParameters.m_CellBias->GetTensorInfo(), dataType);
508 = OverrideDataType(cLayer->m_BasicParameters.m_OutputGateBias->GetTensorInfo(), dataType);
513 paramsInfo.m_InputToCellWeights = &inputToCellWeights;
514 paramsInfo.m_InputToOutputWeights = &inputToOutputWeights;
515 paramsInfo.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
516 paramsInfo.m_RecurrentToCellWeights = &recurrentToCellWeights;
517 paramsInfo.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
518 paramsInfo.m_ForgetGateBias = &forgetGateBias;
519 paramsInfo.m_CellBias = &cellBias;
520 paramsInfo.m_OutputGateBias = &outputGateBias;
537 if(!descriptor.m_CifgEnabled)
539 optInputToInputWeights =
540 OverrideDataType(cLayer->m_CifgParameters.m_InputToInputWeights->GetTensorInfo(), dataType);
541 paramsInfo.m_InputToInputWeights = &optInputToInputWeights;
543 optRecurrentToInputWeights =
544 OverrideDataType(cLayer->m_CifgParameters.m_RecurrentToInputWeights->GetTensorInfo(), dataType);
545 paramsInfo.m_RecurrentToInputWeights = &optRecurrentToInputWeights;
547 OverrideDataType(cLayer->m_CifgParameters.m_InputGateBias->GetTensorInfo(), dataType);
548 paramsInfo.m_InputGateBias = &optInputGateBias;
551 if(descriptor.m_ProjectionEnabled)
553 optProjectionWeights =
554 OverrideDataType(cLayer->m_ProjectionParameters.m_ProjectionWeights->GetTensorInfo(), dataType);
555 paramsInfo.m_ProjectionWeights = &optProjectionWeights;
556 if (cLayer->m_ProjectionParameters.m_ProjectionBias !=
nullptr)
559 OverrideDataType(cLayer->m_ProjectionParameters.m_ProjectionBias->GetTensorInfo(), dataType);
560 paramsInfo.m_ProjectionBias = &optProjectionBias;
564 if(descriptor.m_PeepholeEnabled)
566 if(!descriptor.m_CifgEnabled)
568 optCellToInputWeights =
569 OverrideDataType(cLayer->m_PeepholeParameters.m_CellToInputWeights->GetTensorInfo(),
571 paramsInfo.m_CellToInputWeights = &optCellToInputWeights;
573 optCellToForgetWeights =
574 OverrideDataType(cLayer->m_PeepholeParameters.m_CellToForgetWeights->GetTensorInfo(), dataType);
575 paramsInfo.m_CellToForgetWeights = &optCellToForgetWeights;
576 optCellToOutputWeights =
577 OverrideDataType(cLayer->m_PeepholeParameters.m_CellToOutputWeights->GetTensorInfo(), dataType);
578 paramsInfo.m_CellToOutputWeights = &optCellToOutputWeights;
581 if(descriptor.m_LayerNormEnabled)
583 if (!descriptor.m_CifgEnabled)
585 optInputLayerNormWeights = OverrideDataType(
586 cLayer->m_LayerNormParameters.m_InputLayerNormWeights->GetTensorInfo(), dataType);
587 paramsInfo.m_InputLayerNormWeights = &optInputLayerNormWeights;
590 optForgetLayerNormWeights = OverrideDataType(
591 cLayer->m_LayerNormParameters.m_ForgetLayerNormWeights->GetTensorInfo(), dataType);
592 paramsInfo.m_ForgetLayerNormWeights = &optForgetLayerNormWeights;
594 optCellLayerNormWeights = OverrideDataType(
595 cLayer->m_LayerNormParameters.m_CellLayerNormWeights->GetTensorInfo(), dataType);
596 paramsInfo.m_CellLayerNormWeights = &optCellLayerNormWeights;
598 optOutputLayerNormWeights = OverrideDataType(
599 cLayer->m_LayerNormParameters.m_OutputLayerNormWeights->GetTensorInfo(), dataType);
600 paramsInfo.m_OutputLayerNormWeights = &optOutputLayerNormWeights;
603 result = layerSupportObject->IsLstmSupported(
622 result = layerSupportObject->IsMaximumSupported(OverrideDataType(input0, dataType),
623 OverrideDataType(input1, dataType),
624 OverrideDataType(output, dataType),
633 result = layerSupportObject->IsMemCopySupported(OverrideDataType(input, dataType),
634 OverrideDataType(output, dataType),
643 result = layerSupportObject->IsMemImportSupported(OverrideDataType(input, dataType),
644 OverrideDataType(output, dataType),
654 result = layerSupportObject->IsMergeSupported(OverrideDataType(input0, dataType),
655 OverrideDataType(input1, dataType),
656 OverrideDataType(output, dataType),
662 auto cLayer = PolymorphicDowncast<const ConcatLayer*>(&layer);
665 auto getTensorInfo = [&dataType](
const InputSlot& slot)
667 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
669 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfo);
670 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfo);
671 std::vector<TensorInfo> inputs(beginI, endI);
677 auto beginPtr = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
678 auto endPtr = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
679 std::vector<const TensorInfo*> inputPtrs(beginPtr, endPtr);
683 result = layerSupportObject->IsConcatSupported(inputPtrs, output, cLayer->GetParameters(), reason);
693 result = layerSupportObject->IsMultiplicationSupported(
694 OverrideDataType(input0, dataType),
695 OverrideDataType(input1, dataType),
696 OverrideDataType(output, dataType),
702 auto cLayer = PolymorphicDowncast<const NormalizationLayer*>(&layer);
705 result = layerSupportObject->IsNormalizationSupported(OverrideDataType(input, dataType),
706 OverrideDataType(output, dataType),
707 cLayer->GetParameters(),
714 result = layerSupportObject->IsOutputSupported(OverrideDataType(output, dataType), reason);
719 auto cLayer = PolymorphicDowncast<const PermuteLayer*>(&layer);
722 result = layerSupportObject->IsPermuteSupported(OverrideDataType(input, dataType),
723 OverrideDataType(output, dataType),
724 cLayer->GetParameters(),
730 auto cLayer = PolymorphicDowncast<const PadLayer*>(&layer);
733 result = layerSupportObject->IsPadSupported(
734 OverrideDataType(input, dataType),
735 OverrideDataType(output, dataType),
736 cLayer->GetParameters(),
742 auto cLayer = PolymorphicDowncast<const Pooling2dLayer*>(&layer);
745 result = layerSupportObject->IsPooling2dSupported(OverrideDataType(input, dataType),
746 OverrideDataType(output, dataType),
747 cLayer->GetParameters(),
753 auto cLayer = PolymorphicDowncast<const PreCompiledLayer*>(&layer);
755 result = layerSupportObject->IsPreCompiledSupported(OverrideDataType(input, dataType),
756 cLayer->GetParameters(),
764 result = layerSupportObject->IsQuantizeSupported(input, output, reason);
769 auto cLayer = PolymorphicDowncast<const QLstmLayer*>(&layer);
787 paramsInfo.
m_InputToCellWeights = &cLayer->m_BasicParameters.m_InputToCellWeights->GetTensorInfo();
791 &cLayer->m_BasicParameters.m_RecurrentToForgetWeights->GetTensorInfo();
793 &cLayer->m_BasicParameters.m_RecurrentToCellWeights->GetTensorInfo();
795 &cLayer->m_BasicParameters.m_RecurrentToOutputWeights->GetTensorInfo();
797 paramsInfo.
m_ForgetGateBias = &cLayer->m_BasicParameters.m_ForgetGateBias->GetTensorInfo();
798 paramsInfo.
m_CellBias = &cLayer->m_BasicParameters.m_CellBias->GetTensorInfo();
799 paramsInfo.
m_OutputGateBias = &cLayer->m_BasicParameters.m_OutputGateBias->GetTensorInfo();
801 if(!descriptor.m_CifgEnabled)
805 &cLayer->m_CifgParameters.m_RecurrentToInputWeights->GetTensorInfo();
806 paramsInfo.
m_InputGateBias = &cLayer->m_CifgParameters.m_InputGateBias->GetTensorInfo();
809 if(descriptor.m_ProjectionEnabled)
811 paramsInfo.
m_ProjectionWeights = &cLayer->m_ProjectionParameters.m_ProjectionWeights->GetTensorInfo();
814 if (cLayer->m_ProjectionParameters.m_ProjectionBias !=
nullptr)
816 paramsInfo.
m_ProjectionBias = &cLayer->m_ProjectionParameters.m_ProjectionBias->GetTensorInfo();
820 if(descriptor.m_PeepholeEnabled)
822 if (!descriptor.m_CifgEnabled)
825 &cLayer->m_PeepholeParameters.m_CellToInputWeights->GetTensorInfo();
829 &cLayer->m_PeepholeParameters.m_CellToForgetWeights->GetTensorInfo();
830 paramsInfo.
m_CellToOutputWeights = &cLayer->m_PeepholeParameters.m_CellToOutputWeights->GetTensorInfo();
833 if(descriptor.m_LayerNormEnabled)
835 if (!descriptor.m_CifgEnabled)
838 &cLayer->m_LayerNormParameters.m_InputLayerNormWeights->GetTensorInfo();
842 &cLayer->m_LayerNormParameters.m_ForgetLayerNormWeights->GetTensorInfo();
844 &cLayer->m_LayerNormParameters.m_CellLayerNormWeights->GetTensorInfo();
846 &cLayer->m_LayerNormParameters.m_OutputLayerNormWeights->GetTensorInfo();
849 result = layerSupportObject->IsQLstmSupported(input,
862 auto cLayer = PolymorphicDowncast<const QuantizedLstmLayer*>(&layer);
877 &cLayer->m_QuantizedLstmParameters.m_InputToInputWeights->GetTensorInfo();
879 &cLayer->m_QuantizedLstmParameters.m_InputToForgetWeights->GetTensorInfo();
881 &cLayer->m_QuantizedLstmParameters.m_InputToCellWeights->GetTensorInfo();
883 &cLayer->m_QuantizedLstmParameters.m_InputToOutputWeights->GetTensorInfo();
886 &cLayer->m_QuantizedLstmParameters.m_RecurrentToInputWeights->GetTensorInfo();
888 &cLayer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights->GetTensorInfo();
890 &cLayer->m_QuantizedLstmParameters.m_RecurrentToCellWeights->GetTensorInfo();
892 &cLayer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights->GetTensorInfo();
895 &cLayer->m_QuantizedLstmParameters.m_InputGateBias->GetTensorInfo();
897 &cLayer->m_QuantizedLstmParameters.m_ForgetGateBias->GetTensorInfo();
899 &cLayer->m_QuantizedLstmParameters.m_CellBias->GetTensorInfo();
901 &cLayer->m_QuantizedLstmParameters.m_OutputGateBias->GetTensorInfo();;
903 result = layerSupportObject->IsQuantizedLstmSupported(input,
917 result = layerSupportObject->IsDivisionSupported(
918 OverrideDataType(input0, dataType),
919 OverrideDataType(input1, dataType),
920 OverrideDataType(output, dataType),
928 result = layerSupportObject->IsRankSupported(OverrideDataType(input, dataType),
929 OverrideDataType(output, dataType),
935 auto cLayer = PolymorphicDowncast<const ReshapeLayer*>(&layer);
938 result = layerSupportObject->IsReshapeSupported(OverrideDataType(input, dataType),
939 OverrideDataType(output, dataType),
940 cLayer->GetParameters(),
946 auto cLayer = PolymorphicDowncast<const ResizeLayer*>(&layer);
949 result = layerSupportObject->IsResizeSupported(OverrideDataType(input, dataType),
950 OverrideDataType(output, dataType),
951 cLayer->GetParameters(),
957 auto cLayer = PolymorphicDowncast<const SliceLayer*>(&layer);
962 result = layerSupportObject->IsSliceSupported(OverrideDataType(input, dataType),
963 OverrideDataType(output, dataType),
964 cLayer->GetParameters(),
970 auto cLayer = PolymorphicDowncast<const SoftmaxLayer*>(&layer);
973 result = layerSupportObject->IsSoftmaxSupported(OverrideDataType(input, dataType),
974 OverrideDataType(output, dataType),
975 cLayer->GetParameters(),
981 auto cLayer = PolymorphicDowncast<const SpaceToBatchNdLayer*>(&layer);
984 result = layerSupportObject->IsSpaceToBatchNdSupported(OverrideDataType(input, dataType),
985 OverrideDataType(output, dataType),
986 cLayer->GetParameters(),
992 auto cLayer = PolymorphicDowncast<const SpaceToDepthLayer*>(&layer);
997 result = layerSupportObject->IsSpaceToDepthSupported(OverrideDataType(input, dataType),
998 OverrideDataType(output, dataType),
999 cLayer->GetParameters(),
1005 auto cLayer = PolymorphicDowncast<const SplitterLayer*>(&layer);
1009 auto getTensorInfo = [&dataType](
const OutputSlot& slot)
1011 return OverrideDataType(slot.GetTensorInfo(), dataType);
1013 auto beginI = boost::make_transform_iterator(layer.
GetOutputSlots().begin(), getTensorInfo);
1014 auto endI = boost::make_transform_iterator(layer.
GetOutputSlots().end(), getTensorInfo);
1015 std::vector<TensorInfo> outputs(beginI, endI);
1017 const std::vector<std::reference_wrapper<TensorInfo>> outputPtrs(outputs.begin(), outputs.end());
1019 result = layerSupportObject->IsSplitterSupported(OverrideDataType(input, dataType),
1021 cLayer->GetParameters(),
1027 auto cLayer = PolymorphicDowncast<const StackLayer*>(&layer);
1030 auto getTensorInfo = [&dataType](
const InputSlot& slot)
1032 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
1034 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfo);
1035 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfo);
1036 std::vector<TensorInfo> inputs(beginI, endI);
1042 auto beginPtr = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
1043 auto endPtr = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
1044 std::vector<const TensorInfo*> inputPtrs(beginPtr, endPtr);
1048 result = layerSupportObject->IsStackSupported(inputPtrs, output, cLayer->GetParameters(), reason);
1054 auto cLayer = PolymorphicDowncast<const StandInLayer*>(&layer);
1057 auto getTensorInfoIn = [&dataType](
const InputSlot& slot)
1059 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
1061 auto getTensorInfoOut = [&dataType](
const OutputSlot& slot)
1063 return OverrideDataType(slot.GetTensorInfo(), dataType);
1065 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfoIn);
1066 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfoIn);
1067 std::vector<TensorInfo> inputs(beginI, endI);
1069 auto beginO = boost::make_transform_iterator(layer.
GetOutputSlots().begin(), getTensorInfoOut);
1070 auto endO = boost::make_transform_iterator(layer.
GetOutputSlots().end(), getTensorInfoOut);
1071 std::vector<TensorInfo> outputs(beginO, endO);
1078 auto beginPtrI = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
1079 auto endPtrI = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
1080 std::vector<const TensorInfo*> inputPtrs(beginPtrI, endPtrI);
1082 auto beginPtrO = boost::make_transform_iterator(outputs.begin(), getTensorInfoPtr);
1083 auto endPtrO = boost::make_transform_iterator(outputs.end(), getTensorInfoPtr);
1084 std::vector<const TensorInfo*> outputPtrs(beginPtrO, endPtrO);
1087 result = layerSupportObject->IsStandInSupported(inputPtrs,
1089 cLayer->GetParameters(),
1095 auto cLayer = PolymorphicDowncast<const StridedSliceLayer*>(&layer);
1098 result = layerSupportObject->IsStridedSliceSupported(OverrideDataType(input, dataType),
1099 OverrideDataType(output, dataType),
1100 cLayer->GetParameters(),
1109 result = layerSupportObject->IsSubtractionSupported(
1110 OverrideDataType(input0, dataType),
1111 OverrideDataType(input1, dataType),
1112 OverrideDataType(output, dataType),
1122 result = layerSupportObject->IsSwitchSupported(OverrideDataType(input0, dataType),
1123 OverrideDataType(input1, dataType),
1124 OverrideDataType(output0, dataType),
1125 OverrideDataType(output1, dataType),
1131 auto cLayer = PolymorphicDowncast<const MeanLayer*>(&layer);
1134 result = layerSupportObject->IsMeanSupported(
1135 OverrideDataType(input, dataType),
1136 OverrideDataType(output, dataType),
1137 cLayer->GetParameters(),
1146 result = layerSupportObject->IsMinimumSupported(OverrideDataType(input0, dataType),
1147 OverrideDataType(input1, dataType),
1148 OverrideDataType(output, dataType),
1157 result = layerSupportObject->IsPreluSupported(OverrideDataType(input, dataType),
1158 OverrideDataType(alpha, dataType),
1159 OverrideDataType(output, dataType),
1165 auto cLayer = PolymorphicDowncast<const TransposeLayer*>(&layer);
1168 result = layerSupportObject->IsTransposeSupported(OverrideDataType(input, dataType),
1169 OverrideDataType(output, dataType),
1170 cLayer->GetParameters(),
1176 auto cLayer = PolymorphicDowncast<const TransposeConvolution2dLayer*>(&layer);
1185 if (descriptor.m_BiasEnabled)
1188 biases = OverrideDataType(cLayer->m_Bias->GetTensorInfo(),
1193 const TensorInfo weights = OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType);
1195 result = layerSupportObject->IsTransposeConvolution2dSupported(input,
1206 ARMNN_ASSERT_MSG(
false,
"WorkloadFactory did not recognise type of layer.");
1207 reason.
value() =
"Unrecognised layer type";
1217 std::string& outReasonIfUnsupported)
1219 auto layer = PolymorphicDowncast<const Layer*>(&connectableLayer);
1220 return IsLayerSupported(layer->GetBackendId(), connectableLayer, dataType, outReasonIfUnsupported);
1227 return std::unique_ptr<IWorkload>();
1233 return std::unique_ptr<IWorkload>();
1239 return std::unique_ptr<IWorkload>();
1245 return std::unique_ptr<IWorkload>();
1251 return std::unique_ptr<IWorkload>();
1257 return std::unique_ptr<IWorkload>();
1263 return std::unique_ptr<IWorkload>();
1269 return std::unique_ptr<IWorkload>();
1275 return std::unique_ptr<IWorkload>();
1281 return std::unique_ptr<IWorkload>();
1287 return std::unique_ptr<IWorkload>();
1293 return std::unique_ptr<IWorkload>();
1299 return std::unique_ptr<IWorkload>();
1305 return std::unique_ptr<IWorkload>();
1311 return std::unique_ptr<IWorkload>();
1317 return std::unique_ptr<IWorkload>();
1323 return std::unique_ptr<IWorkload>();
1329 return std::unique_ptr<IWorkload>();
1335 return std::unique_ptr<IWorkload>();
1341 return std::unique_ptr<IWorkload>();
1347 return std::unique_ptr<IWorkload>();
1353 return std::unique_ptr<IWorkload>();
1359 return std::unique_ptr<IWorkload>();
1365 return std::unique_ptr<IWorkload>();
1371 return std::unique_ptr<IWorkload>();
1377 return std::unique_ptr<IWorkload>();
1383 return std::unique_ptr<IWorkload>();
1389 return std::unique_ptr<IWorkload>();
1396 return std::unique_ptr<IWorkload>();
1402 return std::unique_ptr<IWorkload>();
1408 return std::unique_ptr<IWorkload>();
1414 return std::unique_ptr<IWorkload>();
1420 return std::unique_ptr<IWorkload>();
1426 return std::unique_ptr<IWorkload>();
1432 return std::unique_ptr<IWorkload>();
1438 return std::unique_ptr<IWorkload>();
1444 return std::unique_ptr<IWorkload>();
1450 return std::unique_ptr<IWorkload>();
1456 return std::unique_ptr<IWorkload>();
1462 return std::unique_ptr<IWorkload>();
1468 return std::unique_ptr<IWorkload>();
1474 return std::unique_ptr<IWorkload>();
1480 return std::unique_ptr<IWorkload>();
1486 return std::unique_ptr<IWorkload>();
1492 return std::unique_ptr<IWorkload>();
1498 return std::unique_ptr<IWorkload>();
1504 return std::unique_ptr<IWorkload>();
1510 return std::unique_ptr<IWorkload>();
1516 return std::unique_ptr<IWorkload>();
1522 return std::unique_ptr<IWorkload>();
1527 return std::unique_ptr<IWorkload>();
1533 return std::unique_ptr<IWorkload>();
1539 return std::unique_ptr<IWorkload>();
1545 return std::unique_ptr<IWorkload>();
1551 return std::unique_ptr<IWorkload>();
1557 return std::unique_ptr<IWorkload>();
1563 return std::unique_ptr<IWorkload>();
1569 return std::unique_ptr<IWorkload>();
1575 return std::unique_ptr<IWorkload>();
1581 return std::unique_ptr<IWorkload>();
1587 return std::unique_ptr<IWorkload>();
1593 return std::unique_ptr<IWorkload>();
1599 return std::unique_ptr<IWorkload>();
1605 return std::unique_ptr<IWorkload>();
1611 return std::unique_ptr<IWorkload>();
1618 return std::unique_ptr<IWorkload>();
virtual std::unique_ptr< IWorkload > CreateSplitter(const SplitterQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateBatchNormalization(const BatchNormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateDebug(const DebugQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMemCopy(const MemCopyQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateL2Normalization(const L2NormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
virtual std::unique_ptr< IWorkload > CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor &descriptor, const WorkloadInfo &Info) const
virtual std::unique_ptr< IWorkload > CreateMultiplication(const MultiplicationQueueDescriptor &descriptor, const WorkloadInfo &info) const
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
virtual std::unique_ptr< IWorkload > CreateInstanceNormalization(const InstanceNormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateGreater(const GreaterQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateArgMinMax(const ArgMinMaxQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMerger(const MergerQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateLogSoftmax(const LogSoftmaxQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateResizeBilinear(const ResizeBilinearQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateStridedSlice(const StridedSliceQueueDescriptor &descriptor, const WorkloadInfo &Info) const
A Convolution2dDescriptor for the Convolution2dLayer.
virtual std::unique_ptr< IWorkload > CreateStack(const StackQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateLstm(const LstmQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateFakeQuantization(const FakeQuantizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateQuantizedLstm(const QuantizedLstmQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateQLstm(const QLstmQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateConstant(const ConstantQueueDescriptor &descriptor, const WorkloadInfo &info) const
BackendRegistry & BackendRegistryInstance()
virtual std::unique_ptr< IWorkload > CreateElementwiseUnary(const ElementwiseUnaryQueueDescriptor &descriptor, const WorkloadInfo &Info) const
std::vector< float > boxEncodings({ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f })
virtual std::unique_ptr< IWorkload > CreateAbs(const AbsQueueDescriptor &descriptor, const WorkloadInfo &info) const
Copyright (c) 2020 ARM Limited.
const std::vector< InputSlot > & GetInputSlots() const
virtual std::unique_ptr< IWorkload > CreateActivation(const ActivationQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateRsqrt(const RsqrtQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateTranspose(const TransposeQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateDivision(const DivisionQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateConvertFp32ToBf16(const ConvertFp32ToBf16QueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMaximum(const MaximumQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateConcat(const ConcatQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMerge(const MergeQueueDescriptor &descriptor, const WorkloadInfo &info) const
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
armnn::Optional< armnn::DataType > GetBiasTypeFromWeightsType(armnn::Optional< armnn::DataType > weightsType)
virtual std::unique_ptr< IWorkload > CreateConvertBf16ToFp32(const ConvertBf16ToFp32QueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateEqual(const EqualQueueDescriptor &descriptor, const WorkloadInfo &Info) const
virtual std::unique_ptr< IWorkload > CreateRank(const RankQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateDetectionPostProcess(const DetectionPostProcessQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor &descriptor, const WorkloadInfo &info) const
An LstmDescriptor for the LstmLayer.
virtual std::unique_ptr< IWorkload > CreateResize(const ResizeQueueDescriptor &descriptor, const WorkloadInfo &info) const
#define ARMNN_ASSERT_MSG(COND, MSG)
A L2NormalizationDescriptor for the L2NormalizationLayer.
An ArgMinMaxDescriptor for ArgMinMaxLayer.
virtual std::unique_ptr< IWorkload > CreateQuantize(const QuantizeQueueDescriptor &descriptor, const WorkloadInfo &Info) const
A FullyConnectedDescriptor for the FullyConnectedLayer.
bool m_BiasEnabled
Enable/disable bias.
A GatherDescriptor for the GatherLayer.
virtual std::unique_ptr< IWorkload > CreateSwitch(const SwitchQueueDescriptor &descriptor, const WorkloadInfo &Info) const
virtual std::unique_ptr< IWorkload > CreatePad(const PadQueueDescriptor &descriptor, const WorkloadInfo &Info) const
#define ARMNN_ASSERT(COND)
A QLstmDescriptor for the QLstmLayer.
static bool IsLayerSupported(const BackendId &backendId, const IConnectableLayer &layer, Optional< DataType > dataType, std::string &outReasonIfUnsupported)
virtual std::unique_ptr< IWorkload > CreateNormalization(const NormalizationQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateReshape(const ReshapeQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreatePermute(const PermuteQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateFill(const FillQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateComparison(const ComparisonQueueDescriptor &descriptor, const WorkloadInfo &Info) const
const std::vector< OutputSlot > & GetOutputSlots() const
virtual std::unique_ptr< IWorkload > CreatePooling2d(const Pooling2dQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateSpaceToDepth(const SpaceToDepthQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateGather(const GatherQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateConvertFp32ToFp16(const ConvertFp32ToFp16QueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMinimum(const MinimumQueueDescriptor &descriptor, const WorkloadInfo &info) const
std::vector< float > scores({ 0.0f, 0.9f, 0.8f, 0.0f, 0.75f, 0.72f, 0.0f, 0.6f, 0.5f, 0.0f, 0.93f, 0.95f, 0.0f, 0.5f, 0.4f, 0.0f, 0.3f, 0.2f })
virtual std::unique_ptr< IWorkload > CreateDepthToSpace(const DepthToSpaceQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateSlice(const SliceQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateAddition(const AdditionQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateTransposeConvolution2d(const TransposeConvolution2dQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMean(const MeanQueueDescriptor &descriptor, const WorkloadInfo &Info) const
virtual std::unique_ptr< IWorkload > CreateOutput(const OutputQueueDescriptor &descriptor, const WorkloadInfo &info) const
LayerType GetType() const
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
Get the const output slot handle by slot index.
virtual const TensorInfo & GetTensorInfo() const =0
virtual std::unique_ptr< IWorkload > CreateSoftmax(const SoftmaxQueueDescriptor &descriptor, const WorkloadInfo &info) const
Contains information about inputs and outputs to a layer.
virtual const char * GetName() const =0
Returns the name of the layer.
virtual std::unique_ptr< IWorkload > CreateFullyConnected(const FullyConnectedQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateDepthwiseConvolution2d(const DepthwiseConvolution2dQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateFloor(const FloorQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateMemImport(const MemImportQueueDescriptor &descriptor, const WorkloadInfo &info) const
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
virtual std::unique_ptr< IWorkload > CreateSubtraction(const SubtractionQueueDescriptor &descriptor, const WorkloadInfo &info) const
const TensorInfo & GetTensorInfo() const override
virtual std::unique_ptr< IWorkload > CreatePreCompiled(const PreCompiledQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreateConvertFp16ToFp32(const ConvertFp16ToFp32QueueDescriptor &descriptor, const WorkloadInfo &info) const
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
A FillDescriptor for the FillLayer.
virtual std::unique_ptr< IWorkload > CreateConvolution2d(const Convolution2dQueueDescriptor &descriptor, const WorkloadInfo &info) const
virtual std::unique_ptr< IWorkload > CreatePrelu(const PreluQueueDescriptor &descriptor, const WorkloadInfo &info) const
std::vector< float > anchors({ 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 100.5f, 1.0f, 1.0f })
virtual std::unique_ptr< IWorkload > CreateDequantize(const DequantizeQueueDescriptor &descriptor, const WorkloadInfo &info) const