21 #include <boost/cast.hpp> 22 #include <boost/iterator/transform_iterator.hpp> 33 const TensorInfo OverrideDataType(
const TensorInfo& info, Optional<DataType> type)
40 return TensorInfo(info.GetShape(), type.value(), info.GetQuantizationScale(), info.GetQuantizationOffset());
48 std::string& outReasonIfUnsupported)
52 const Layer& layer = *(boost::polymorphic_downcast<const Layer*>(&connectableLayer));
55 if (!backendRegistry.IsBackendRegistered(backendId))
58 ss << connectableLayer.
GetName() <<
" is not supported on " << backendId
59 <<
" because this backend is not registered.";
61 outReasonIfUnsupported = ss.str();
65 auto backendFactory = backendRegistry.GetFactory(backendId);
66 auto backendObject = backendFactory();
67 auto layerSupportObject = backendObject->GetLayerSupport();
73 auto cLayer = boost::polymorphic_downcast<const ActivationLayer*>(&layer);
76 result = layerSupportObject->IsActivationSupported(
77 OverrideDataType(input, dataType),
78 OverrideDataType(output, dataType),
79 cLayer->GetParameters(),
88 result = layerSupportObject->IsAdditionSupported(
89 OverrideDataType(input0, dataType),
90 OverrideDataType(input1, dataType),
91 OverrideDataType(output, dataType),
97 auto cLayer = boost::polymorphic_downcast<const ArgMinMaxLayer*>(&layer);
102 result = layerSupportObject->IsArgMinMaxSupported(
103 OverrideDataType(input, dataType),
111 auto cLayer = boost::polymorphic_downcast<const BatchNormalizationLayer*>(&layer);
114 const TensorInfo& mean = cLayer->m_Mean->GetTensorInfo();
115 const TensorInfo& var = cLayer->m_Variance->GetTensorInfo();
116 const TensorInfo& beta = cLayer->m_Beta->GetTensorInfo();
117 const TensorInfo& gamma = cLayer->m_Gamma->GetTensorInfo();
118 result = layerSupportObject->IsBatchNormalizationSupported(
119 OverrideDataType(input, dataType),
120 OverrideDataType(output, dataType),
121 OverrideDataType(mean, dataType),
122 OverrideDataType(var, dataType),
123 OverrideDataType(beta, dataType),
124 OverrideDataType(gamma, dataType),
125 cLayer->GetParameters(),
133 auto cLayer = boost::polymorphic_downcast<const BatchToSpaceNdLayer*>(&layer);
135 result = layerSupportObject->IsBatchToSpaceNdSupported(OverrideDataType(input, dataType),
136 OverrideDataType(output, dataType),
137 cLayer->GetParameters(),
143 auto cLayer = boost::polymorphic_downcast<const ComparisonLayer*>(&layer);
149 result = layerSupportObject->IsComparisonSupported(OverrideDataType(input0, dataType),
150 OverrideDataType(input1, dataType),
152 cLayer->GetParameters(),
159 result = layerSupportObject->IsConstantSupported(OverrideDataType(output, dataType), reason);
166 result = layerSupportObject->IsConvertFp16ToFp32Supported(input, output, reason);
173 result = layerSupportObject->IsConvertFp32ToFp16Supported(input, output, reason);
178 auto cLayer = boost::polymorphic_downcast<const Convolution2dLayer*>(&layer);
183 BOOST_ASSERT(cLayer->m_Weight.get() !=
nullptr);
189 if (descriptor.m_BiasEnabled)
195 result = layerSupportObject->IsConvolution2dSupported(
199 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
209 result = layerSupportObject->IsDebugSupported(OverrideDataType(input, dataType),
210 OverrideDataType(output, dataType),
216 auto cLayer = boost::polymorphic_downcast<const DepthToSpaceLayer*>(&layer);
221 result = layerSupportObject->IsDepthToSpaceSupported(OverrideDataType(input, dataType),
222 OverrideDataType(output, dataType),
223 cLayer->GetParameters(),
229 auto cLayer = boost::polymorphic_downcast<const DepthwiseConvolution2dLayer*>(&layer);
233 BOOST_ASSERT(cLayer->m_Weight.get() !=
nullptr);
239 if (descriptor.m_BiasEnabled)
245 result = layerSupportObject->IsDepthwiseConvolutionSupported(
249 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
259 result = layerSupportObject->IsDequantizeSupported(input,
260 OverrideDataType(output, dataType),
266 auto cLayer = boost::polymorphic_downcast<const DetectionPostProcessLayer*>(&layer);
277 result = layerSupportObject->IsDetectionPostProcessSupported(boxEncodings,
290 auto cLayer = boost::polymorphic_downcast<const ElementwiseUnaryLayer*>(&layer);
295 result = layerSupportObject->IsElementwiseUnarySupported(OverrideDataType(input, dataType),
296 OverrideDataType(output, dataType),
297 cLayer->GetParameters(),
303 auto cLayer = boost::polymorphic_downcast<const FakeQuantizationLayer*>(&layer);
305 result = layerSupportObject->IsFakeQuantizationSupported(OverrideDataType(input, dataType),
306 cLayer->GetParameters(),
314 result = layerSupportObject->IsFloorSupported(OverrideDataType(input, dataType),
315 OverrideDataType(output, dataType),
321 auto cLayer = boost::polymorphic_downcast<const FullyConnectedLayer*>(&layer);
324 BOOST_ASSERT(cLayer->m_Weight.get() !=
nullptr);
336 BOOST_ASSERT(cLayer->m_Bias.get() !=
nullptr);
338 biasInfoPtr = &biasInfo;
343 switch(input.GetDataType())
347 biasInfoPtr = &dummyBFloat16Bias;
352 biasInfoPtr = &dummyFloat16Bias;
357 biasInfoPtr = &dummyFloat32Bias;
365 biasInfoPtr = &dummyQA8Bias;
370 BOOST_ASSERT_MSG(
false,
"Unexpected bias type");
375 result = layerSupportObject->IsFullyConnectedSupported(
376 OverrideDataType(input, dataType),
377 OverrideDataType(output, dataType),
378 OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType),
389 result = layerSupportObject->IsGatherSupported(OverrideDataType(input0, dataType),
391 OverrideDataType(output, dataType),
398 result = layerSupportObject->IsInputSupported(OverrideDataType(input, dataType), reason);
403 auto cLayer = boost::polymorphic_downcast<const InstanceNormalizationLayer*>(&layer);
409 result = layerSupportObject->IsInstanceNormalizationSupported(
410 OverrideDataType(input, dataType),
411 OverrideDataType(output, dataType),
418 auto cLayer = boost::polymorphic_downcast<const L2NormalizationLayer*>(&layer);
424 result = layerSupportObject->IsL2NormalizationSupported(
425 OverrideDataType(input, dataType),
426 OverrideDataType(output, dataType),
433 auto cLayer = boost::polymorphic_downcast<const LogSoftmaxLayer*>(&layer);
438 result = layerSupportObject->IsLogSoftmaxSupported(OverrideDataType(input, dataType),
439 OverrideDataType(output, dataType),
440 cLayer->GetParameters(),
446 auto cLayer = boost::polymorphic_downcast<const LstmLayer*>(&layer);
464 = OverrideDataType(cLayer->m_BasicParameters.m_InputToForgetWeights->GetTensorInfo(), dataType);
466 = OverrideDataType(cLayer->m_BasicParameters.m_InputToCellWeights->GetTensorInfo(), dataType);
468 = OverrideDataType(cLayer->m_BasicParameters.m_InputToOutputWeights->GetTensorInfo(), dataType);
470 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToForgetWeights->GetTensorInfo(), dataType);
472 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToCellWeights->GetTensorInfo(), dataType);
474 = OverrideDataType(cLayer->m_BasicParameters.m_RecurrentToOutputWeights->GetTensorInfo(), dataType);
476 = OverrideDataType(cLayer->m_BasicParameters.m_ForgetGateBias->GetTensorInfo(), dataType);
478 = OverrideDataType(cLayer->m_BasicParameters.m_CellBias->GetTensorInfo(), dataType);
480 = OverrideDataType(cLayer->m_BasicParameters.m_OutputGateBias->GetTensorInfo(), dataType);
485 paramsInfo.m_InputToCellWeights = &inputToCellWeights;
486 paramsInfo.m_InputToOutputWeights = &inputToOutputWeights;
487 paramsInfo.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
488 paramsInfo.m_RecurrentToCellWeights = &recurrentToCellWeights;
489 paramsInfo.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
490 paramsInfo.m_ForgetGateBias = &forgetGateBias;
491 paramsInfo.m_CellBias = &cellBias;
492 paramsInfo.m_OutputGateBias = &outputGateBias;
509 if(!descriptor.m_CifgEnabled)
511 optInputToInputWeights =
512 OverrideDataType(cLayer->m_CifgParameters.m_InputToInputWeights->GetTensorInfo(), dataType);
513 paramsInfo.m_InputToInputWeights = &optInputToInputWeights;
515 optRecurrentToInputWeights =
516 OverrideDataType(cLayer->m_CifgParameters.m_RecurrentToInputWeights->GetTensorInfo(), dataType);
517 paramsInfo.m_RecurrentToInputWeights = &optRecurrentToInputWeights;
518 if (cLayer->m_CifgParameters.m_CellToInputWeights !=
nullptr)
520 optCellToInputWeights =
521 OverrideDataType(cLayer->m_CifgParameters.m_CellToInputWeights->GetTensorInfo(), dataType);
522 paramsInfo.m_CellToInputWeights = &optCellToInputWeights;
525 OverrideDataType(cLayer->m_CifgParameters.m_InputGateBias->GetTensorInfo(), dataType);
526 paramsInfo.m_InputGateBias = &optInputGateBias;
529 if(descriptor.m_ProjectionEnabled)
531 optProjectionWeights =
532 OverrideDataType(cLayer->m_ProjectionParameters.m_ProjectionWeights->GetTensorInfo(), dataType);
533 paramsInfo.m_ProjectionWeights = &optProjectionWeights;
534 if (cLayer->m_ProjectionParameters.m_ProjectionBias !=
nullptr)
537 OverrideDataType(cLayer->m_ProjectionParameters.m_ProjectionBias->GetTensorInfo(), dataType);
538 paramsInfo.m_ProjectionBias = &optProjectionBias;
542 if(descriptor.m_PeepholeEnabled)
544 optCellToForgetWeights =
545 OverrideDataType(cLayer->m_PeepholeParameters.m_CellToForgetWeights->GetTensorInfo(), dataType);
546 paramsInfo.m_CellToForgetWeights = &optCellToForgetWeights;
547 optCellToOutputWeights =
548 OverrideDataType(cLayer->m_PeepholeParameters.m_CellToOutputWeights->GetTensorInfo(), dataType);
549 paramsInfo.m_CellToOutputWeights = &optCellToOutputWeights;
552 if(descriptor.m_LayerNormEnabled)
554 if (!descriptor.m_CifgEnabled)
556 optInputLayerNormWeights = OverrideDataType(
557 cLayer->m_LayerNormParameters.m_InputLayerNormWeights->GetTensorInfo(), dataType);
558 paramsInfo.m_InputLayerNormWeights = &optInputLayerNormWeights;
561 optForgetLayerNormWeights = OverrideDataType(
562 cLayer->m_LayerNormParameters.m_ForgetLayerNormWeights->GetTensorInfo(), dataType);
563 paramsInfo.m_ForgetLayerNormWeights = &optForgetLayerNormWeights;
565 optCellLayerNormWeights = OverrideDataType(
566 cLayer->m_LayerNormParameters.m_CellLayerNormWeights->GetTensorInfo(), dataType);
567 paramsInfo.m_CellLayerNormWeights = &optCellLayerNormWeights;
569 optOutputLayerNormWeights = OverrideDataType(
570 cLayer->m_LayerNormParameters.m_OutputLayerNormWeights->GetTensorInfo(), dataType);
571 paramsInfo.m_OutputLayerNormWeights = &optOutputLayerNormWeights;
574 result = layerSupportObject->IsLstmSupported(
593 result = layerSupportObject->IsMaximumSupported(OverrideDataType(input0, dataType),
594 OverrideDataType(input1, dataType),
595 OverrideDataType(output, dataType),
604 result = layerSupportObject->IsMemCopySupported(OverrideDataType(input, dataType),
605 OverrideDataType(output, dataType),
614 result = layerSupportObject->IsMemImportSupported(OverrideDataType(input, dataType),
615 OverrideDataType(output, dataType),
625 result = layerSupportObject->IsMergeSupported(OverrideDataType(input0, dataType),
626 OverrideDataType(input1, dataType),
627 OverrideDataType(output, dataType),
633 auto cLayer = boost::polymorphic_downcast<const ConcatLayer*>(&layer);
636 auto getTensorInfo = [&dataType](
const InputSlot& slot)
638 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
640 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfo);
641 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfo);
642 std::vector<TensorInfo> inputs(beginI, endI);
648 auto beginPtr = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
649 auto endPtr = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
650 std::vector<const TensorInfo*> inputPtrs(beginPtr, endPtr);
654 result = layerSupportObject->IsConcatSupported(inputPtrs, output, cLayer->GetParameters(), reason);
664 result = layerSupportObject->IsMultiplicationSupported(
665 OverrideDataType(input0, dataType),
666 OverrideDataType(input1, dataType),
667 OverrideDataType(output, dataType),
673 auto cLayer = boost::polymorphic_downcast<const NormalizationLayer*>(&layer);
676 result = layerSupportObject->IsNormalizationSupported(OverrideDataType(input, dataType),
677 OverrideDataType(output, dataType),
678 cLayer->GetParameters(),
685 result = layerSupportObject->IsOutputSupported(OverrideDataType(output, dataType), reason);
690 auto cLayer = boost::polymorphic_downcast<const PermuteLayer*>(&layer);
693 result = layerSupportObject->IsPermuteSupported(OverrideDataType(input, dataType),
694 OverrideDataType(output, dataType),
695 cLayer->GetParameters(),
701 auto cLayer = boost::polymorphic_downcast<const PadLayer*>(&layer);
704 result = layerSupportObject->IsPadSupported(
705 OverrideDataType(input, dataType),
706 OverrideDataType(output, dataType),
707 cLayer->GetParameters(),
713 auto cLayer = boost::polymorphic_downcast<const Pooling2dLayer*>(&layer);
716 result = layerSupportObject->IsPooling2dSupported(OverrideDataType(input, dataType),
717 OverrideDataType(output, dataType),
718 cLayer->GetParameters(),
724 auto cLayer = boost::polymorphic_downcast<const PreCompiledLayer*>(&layer);
726 result = layerSupportObject->IsPreCompiledSupported(OverrideDataType(input, dataType),
727 cLayer->GetParameters(),
735 result = layerSupportObject->IsQuantizeSupported(input, output, reason);
740 auto cLayer = boost::polymorphic_downcast<const QuantizedLstmLayer*>(&layer);
755 &cLayer->m_QuantizedLstmParameters.m_InputToInputWeights->GetTensorInfo();
757 &cLayer->m_QuantizedLstmParameters.m_InputToForgetWeights->GetTensorInfo();
759 &cLayer->m_QuantizedLstmParameters.m_InputToCellWeights->GetTensorInfo();
761 &cLayer->m_QuantizedLstmParameters.m_InputToOutputWeights->GetTensorInfo();
764 &cLayer->m_QuantizedLstmParameters.m_RecurrentToInputWeights->GetTensorInfo();
766 &cLayer->m_QuantizedLstmParameters.m_RecurrentToForgetWeights->GetTensorInfo();
768 &cLayer->m_QuantizedLstmParameters.m_RecurrentToCellWeights->GetTensorInfo();
770 &cLayer->m_QuantizedLstmParameters.m_RecurrentToOutputWeights->GetTensorInfo();
773 &cLayer->m_QuantizedLstmParameters.m_InputGateBias->GetTensorInfo();
775 &cLayer->m_QuantizedLstmParameters.m_ForgetGateBias->GetTensorInfo();
777 &cLayer->m_QuantizedLstmParameters.m_CellBias->GetTensorInfo();
779 &cLayer->m_QuantizedLstmParameters.m_OutputGateBias->GetTensorInfo();;
781 result = layerSupportObject->IsQuantizedLstmSupported(input,
795 result = layerSupportObject->IsDivisionSupported(
796 OverrideDataType(input0, dataType),
797 OverrideDataType(input1, dataType),
798 OverrideDataType(output, dataType),
804 auto cLayer = boost::polymorphic_downcast<const ReshapeLayer*>(&layer);
807 result = layerSupportObject->IsReshapeSupported(OverrideDataType(input, dataType),
808 OverrideDataType(output, dataType),
809 cLayer->GetParameters(),
815 auto cLayer = boost::polymorphic_downcast<const ResizeLayer*>(&layer);
818 result = layerSupportObject->IsResizeSupported(OverrideDataType(input, dataType),
819 OverrideDataType(output, dataType),
820 cLayer->GetParameters(),
826 auto cLayer = boost::polymorphic_downcast<const SliceLayer*>(&layer);
831 result = layerSupportObject->IsSliceSupported(OverrideDataType(input, dataType),
832 OverrideDataType(output, dataType),
833 cLayer->GetParameters(),
839 auto cLayer = boost::polymorphic_downcast<const SoftmaxLayer*>(&layer);
842 result = layerSupportObject->IsSoftmaxSupported(OverrideDataType(input, dataType),
843 OverrideDataType(output, dataType),
844 cLayer->GetParameters(),
850 auto cLayer = boost::polymorphic_downcast<const SpaceToBatchNdLayer*>(&layer);
853 result = layerSupportObject->IsSpaceToBatchNdSupported(OverrideDataType(input, dataType),
854 OverrideDataType(output, dataType),
855 cLayer->GetParameters(),
861 auto cLayer = boost::polymorphic_downcast<const SpaceToDepthLayer*>(&layer);
866 result = layerSupportObject->IsSpaceToDepthSupported(OverrideDataType(input, dataType),
867 OverrideDataType(output, dataType),
868 cLayer->GetParameters(),
874 auto cLayer = boost::polymorphic_downcast<const SplitterLayer*>(&layer);
878 auto getTensorInfo = [&dataType](
const OutputSlot& slot)
880 return OverrideDataType(slot.GetTensorInfo(), dataType);
882 auto beginI = boost::make_transform_iterator(layer.
GetOutputSlots().begin(), getTensorInfo);
883 auto endI = boost::make_transform_iterator(layer.
GetOutputSlots().end(), getTensorInfo);
884 std::vector<TensorInfo> outputs(beginI, endI);
886 const std::vector<std::reference_wrapper<TensorInfo>> outputPtrs(outputs.begin(), outputs.end());
888 result = layerSupportObject->IsSplitterSupported(OverrideDataType(input, dataType),
890 cLayer->GetParameters(),
896 auto cLayer = boost::polymorphic_downcast<const StackLayer*>(&layer);
899 auto getTensorInfo = [&dataType](
const InputSlot& slot)
901 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
903 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfo);
904 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfo);
905 std::vector<TensorInfo> inputs(beginI, endI);
911 auto beginPtr = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
912 auto endPtr = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
913 std::vector<const TensorInfo*> inputPtrs(beginPtr, endPtr);
917 result = layerSupportObject->IsStackSupported(inputPtrs, output, cLayer->GetParameters(), reason);
923 auto cLayer = boost::polymorphic_downcast<const StandInLayer*>(&layer);
926 auto getTensorInfoIn = [&dataType](
const InputSlot& slot)
928 return OverrideDataType(slot.GetConnectedOutputSlot()->GetTensorInfo(), dataType);
930 auto getTensorInfoOut = [&dataType](
const OutputSlot& slot)
932 return OverrideDataType(slot.GetTensorInfo(), dataType);
934 auto beginI = boost::make_transform_iterator(layer.
GetInputSlots().begin(), getTensorInfoIn);
935 auto endI = boost::make_transform_iterator(layer.
GetInputSlots().end(), getTensorInfoIn);
936 std::vector<TensorInfo> inputs(beginI, endI);
938 auto beginO = boost::make_transform_iterator(layer.
GetOutputSlots().begin(), getTensorInfoOut);
939 auto endO = boost::make_transform_iterator(layer.
GetOutputSlots().end(), getTensorInfoOut);
940 std::vector<TensorInfo> outputs(beginO, endO);
947 auto beginPtrI = boost::make_transform_iterator(inputs.begin(), getTensorInfoPtr);
948 auto endPtrI = boost::make_transform_iterator(inputs.end(), getTensorInfoPtr);
949 std::vector<const TensorInfo*> inputPtrs(beginPtrI, endPtrI);
951 auto beginPtrO = boost::make_transform_iterator(outputs.begin(), getTensorInfoPtr);
952 auto endPtrO = boost::make_transform_iterator(outputs.end(), getTensorInfoPtr);
953 std::vector<const TensorInfo*> outputPtrs(beginPtrO, endPtrO);
956 result = layerSupportObject->IsStandInSupported(inputPtrs,
958 cLayer->GetParameters(),
964 auto cLayer = boost::polymorphic_downcast<const StridedSliceLayer*>(&layer);
967 result = layerSupportObject->IsStridedSliceSupported(OverrideDataType(input, dataType),
968 OverrideDataType(output, dataType),
969 cLayer->GetParameters(),
978 result = layerSupportObject->IsSubtractionSupported(
979 OverrideDataType(input0, dataType),
980 OverrideDataType(input1, dataType),
981 OverrideDataType(output, dataType),
991 result = layerSupportObject->IsSwitchSupported(OverrideDataType(input0, dataType),
992 OverrideDataType(input1, dataType),
993 OverrideDataType(output0, dataType),
994 OverrideDataType(output1, dataType),
1000 auto cLayer = boost::polymorphic_downcast<const MeanLayer*>(&layer);
1003 result = layerSupportObject->IsMeanSupported(
1004 OverrideDataType(input, dataType),
1005 OverrideDataType(output, dataType),
1006 cLayer->GetParameters(),
1015 result = layerSupportObject->IsMinimumSupported(OverrideDataType(input0, dataType),
1016 OverrideDataType(input1, dataType),
1017 OverrideDataType(output, dataType),
1026 result = layerSupportObject->IsPreluSupported(OverrideDataType(input, dataType),
1027 OverrideDataType(alpha, dataType),
1028 OverrideDataType(output, dataType),
1034 auto cLayer = boost::polymorphic_downcast<const TransposeLayer*>(&layer);
1037 result = layerSupportObject->IsTransposeSupported(OverrideDataType(input, dataType),
1038 OverrideDataType(output, dataType),
1039 cLayer->GetParameters(),
1045 auto cLayer = boost::polymorphic_downcast<const TransposeConvolution2dLayer*>(&layer);
1054 if (descriptor.m_BiasEnabled)
1056 BOOST_ASSERT(cLayer->m_Bias.get() !=
nullptr);
1057 biases = OverrideDataType(cLayer->m_Bias->GetTensorInfo(),
1061 BOOST_ASSERT(cLayer->m_Weight.get() !=
nullptr);
1062 const TensorInfo weights = OverrideDataType(cLayer->m_Weight->GetTensorInfo(), dataType);
1064 result = layerSupportObject->IsTransposeConvolution2dSupported(input,
1075 BOOST_ASSERT_MSG(
false,
"WorkloadFactory did not recognise type of layer.");
1076 reason.
value() =
"Unrecognised layer type";
1086 std::string& outReasonIfUnsupported)
1088 auto layer = boost::polymorphic_downcast<const Layer*>(&connectableLayer);
1089 return IsLayerSupported(layer->GetBackendId(), connectableLayer, dataType, outReasonIfUnsupported);
1096 return std::unique_ptr<IWorkload>();
1102 return std::unique_ptr<IWorkload>();
1108 return std::unique_ptr<IWorkload>();
1114 return std::unique_ptr<IWorkload>();
1120 return std::unique_ptr<IWorkload>();
1126 return std::unique_ptr<IWorkload>();
1132 return std::unique_ptr<IWorkload>();
1138 return std::unique_ptr<IWorkload>();
1144 return std::unique_ptr<IWorkload>();
1150 return std::unique_ptr<IWorkload>();
1156 return std::unique_ptr<IWorkload>();
1162 return std::unique_ptr<IWorkload>();
1168 return std::unique_ptr<IWorkload>();
1174 return std::unique_ptr<IWorkload>();
1180 return std::unique_ptr<IWorkload>();
1186 return std::unique_ptr<IWorkload>();
1192 return std::unique_ptr<IWorkload>();
1198 return std::unique_ptr<IWorkload>();
1204 return std::unique_ptr<IWorkload>();
1210 return std::unique_ptr<IWorkload>();
1216 return std::unique_ptr<IWorkload>();
1222 return std::unique_ptr<IWorkload>();
1228 return std::unique_ptr<IWorkload>();
1234 return std::unique_ptr<IWorkload>();
1240 return std::unique_ptr<IWorkload>();
1247 return std::unique_ptr<IWorkload>();
1253 return std::unique_ptr<IWorkload>();
1259 return std::unique_ptr<IWorkload>();
1265 return std::unique_ptr<IWorkload>();
1271 return std::unique_ptr<IWorkload>();
1277 return std::unique_ptr<IWorkload>();
1283 return std::unique_ptr<IWorkload>();
1289 return std::unique_ptr<IWorkload>();
1295 return std::unique_ptr<IWorkload>();
1301 return std::unique_ptr<IWorkload>();
1307 return std::unique_ptr<IWorkload>();
1313 return std::unique_ptr<IWorkload>();
1319 return std::unique_ptr<IWorkload>();
1325 return std::unique_ptr<IWorkload>();
1331 return std::unique_ptr<IWorkload>();
1337 return std::unique_ptr<IWorkload>();
1343 return std::unique_ptr<IWorkload>();
1349 return std::unique_ptr<IWorkload>();
1355 return std::unique_ptr<IWorkload>();
1361 return std::unique_ptr<IWorkload>();
1367 return std::unique_ptr<IWorkload>();
1373 return std::unique_ptr<IWorkload>();
1379 return std::unique_ptr<IWorkload>();
1385 return std::unique_ptr<IWorkload>();
1391 return std::unique_ptr<IWorkload>();
1397 return std::unique_ptr<IWorkload>();
1403 return std::unique_ptr<IWorkload>();
1409 return std::unique_ptr<IWorkload>();
1415 return std::unique_ptr<IWorkload>();
1421 return std::unique_ptr<IWorkload>();
1427 return std::unique_ptr<IWorkload>();
1433 return std::unique_ptr<IWorkload>();
1439 return std::unique_ptr<IWorkload>();
1445 return std::unique_ptr<IWorkload>();
1451 return std::unique_ptr<IWorkload>();
1458 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 > 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 > 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 > CreateEqual(const EqualQueueDescriptor &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
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.
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
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 > 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.
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