17 #include <fmt/format.h> 27 switch (inputDataType)
29 case DataType::Float16:
30 return DataType::Float16;
32 case DataType::Float32:
33 return DataType::Float32;
34 case DataType::QAsymmS8:
35 return DataType::Signed32;
36 case DataType::QAsymmU8:
37 return DataType::Signed32;
38 case DataType::QSymmS8:
39 return DataType::Signed32;
40 case DataType::QSymmS16:
41 return DataType::Signed32;
44 return DataType::Float32;
54 std::string to_string(T value)
56 std::ostringstream os;
62 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
67 paramName +
" parameter must be set.");
72 void ValidateTensorShapesMatch(
const TensorInfo& first,
74 std::string
const& descName,
75 std::string
const& firstName,
76 std::string
const& secondName)
81 + firstName +
" & " + secondName +
" must have identical shapes");
86 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
91 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
97 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
102 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
108 void ValidateTensorNumDimensions(
const TensorInfo& tensor,
109 std::string
const& descName,
110 unsigned int numDimensions,
111 std::string
const& tensorName)
117 tensorName +
" tensor.");
122 void ValidateTensorNumElements(
const TensorInfo& tensor,
123 std::string
const& descName,
124 unsigned int numElements,
125 std::string
const& tensorName)
131 tensorName +
" tensor.");
136 void ValidateTensorNumDimNumElem(
const TensorInfo& tensorInfo,
137 unsigned int numDimension,
138 unsigned int numElements,
139 std::string
const& tensorName)
141 const std::string functionName{
"ValidateTensorNumDimNumElem"};
142 ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName);
143 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
148 const std::string& descName, std::string
const& tensorName)
157 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
161 tensor.
GetDataType() != DataType::QuantizedSymm8PerAxis)
164 ": Expected data type which supports per-axis quantization scheme but got " +
171 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
173 const std::string& descName,
174 std::string
const& firstName,
175 std::string
const& secondName)
187 if (firstDataType != secondDataType)
190 " must be of the same quantized type, " +
198 " must have the same quantization space, " +
207 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
210 const std::string& descName)
213 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 215 constexpr
float tolerance = 0.000001f;
216 if (std::abs(biasScale - expectedScale) > tolerance)
219 std::stringstream msg;
220 msg << std::setprecision(10) << descName <<
": Expected " << expectedScale <<
221 " quantization scale for bias tensor (the product of the input and weight scales), but got " <<
239 if (weightScales.size() != biasScales.size())
241 std::stringstream msg;
242 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, " 243 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
244 <<
", biases=" << biasScales.size();
248 for (
size_t i = 0ul; i < biasScales.size(); ++i)
251 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
263 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
264 unsigned int numExpected,
265 const std::string& descName,
266 const std::string& varName)
268 if (vec.empty() && numExpected > 0)
273 for (
unsigned int i = 0; i < numExpected; ++i)
283 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
286 std::string
const& descName,
287 std::string
const& firstName,
288 std::string
const& secondName)
295 + firstName +
" & " + secondName
296 +
" must have the same number of dimensions in order to be broadcasted");
299 std::vector<uint32_t> outputDims(numDims, 0u);
300 for (uint32_t i = 0; i < numDims; i++)
303 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
304 if (dimsNotEqual && dimsNotOne)
310 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
311 if (broadcastShape != output.
GetShape())
314 + firstName +
" & " + secondName
315 +
" does not match the output shape");
321 const std::vector<armnn::DataType>& supportedTypes,
322 std::string
const& descName)
324 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
325 if (iterator == supportedTypes.end())
332 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
334 std::string
const& descName,
335 std::string
const& firstName,
336 std::string
const& secondName)
341 " must have identical data types.");
346 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
348 std::string
const& descName,
349 std::string
const& firstName,
350 std::string
const& secondName)
355 " must have the same number of elements.");
359 void ValidateWeightDataType(
const TensorInfo& inputInfo,
361 const std::string& descName)
367 const std::vector<DataType> validTypes =
372 DataType::QuantizedSymm8PerAxis
376 ValidateDataTypes(weightInfo, validTypes, descName);
380 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
384 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
385 const std::string& descName,
386 const std::string& tensorName)
392 "not set on tensor {1}.", descName, tensorName));
395 if (quantizationDim.
value() != 0)
398 "{0}: Quantization dimension for per-axis quantization expected to be 0 on tensor {1}, " 399 "but got: {2}", descName, tensorName, quantizationDim.
value()));
403 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
404 const std::string& descName,
405 const std::string& tensorName)
408 if (quantizationOffset != 0)
411 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
412 descName, tensorName, quantizationOffset));
416 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
420 const std::string& descName)
427 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
429 if (!canHavePerAxisQuantization)
432 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 433 "per-axis quantization.", descName,
"weight"));
437 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
438 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
439 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
447 "{}: Per-axis quantization parameters not set on bias tensor, " 448 "despite being set on weight tensor.", descName));
451 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
452 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
453 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
461 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 463 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
464 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
470 const std::string descriptorName{
"MapQueueDescriptor"};
472 ValidateNumInputs(workloadInfo, descriptorName, 1);
473 ValidateNumOutputs(workloadInfo, descriptorName, 0);
475 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
480 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
488 const std::string descriptorName{
"UnmapQueueDescriptor"};
490 ValidateNumInputs(workloadInfo, descriptorName, 1);
491 ValidateNumOutputs(workloadInfo, descriptorName, 0);
493 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
498 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
506 const std::string descriptorName{
"MemCopyQueueDescriptor"};
508 ValidateNumInputs(workloadInfo, descriptorName, 1);
509 ValidateNumOutputs(workloadInfo, descriptorName , 1);
514 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
515 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
520 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
524 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
529 "{0}: Invalid NULL input {1}.", descriptorName, i));
542 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
543 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
555 "Number of input infos ({0}) does not match the number of output infos ({1})",
565 "Number of elements for tensor input and output {} does not match", i ));
577 "Number of inputs ({0}) does not match the number of outputs ({1})",
581 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
598 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
599 ValidateNumOutputs(workloadInfo,
"MemSyncQueueDescriptor" , 1);
620 const std::string descriptorName{
"ActivationQueueDescriptor"};
622 ValidateNumInputs(workloadInfo, descriptorName, 1);
623 ValidateNumOutputs(workloadInfo, descriptorName, 1);
628 std::vector<DataType> supportedTypes =
638 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
639 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
640 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
645 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
647 ValidateNumInputs(workloadInfo, descriptorName, 1);
648 ValidateNumOutputs(workloadInfo, descriptorName, 1);
659 std::vector<DataType> supportedInputTypes =
671 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
673 auto inputShape = inputTensorInfo.
GetShape();
674 auto outputShape = outputTensorInfo.
GetShape();
679 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
682 if (inputShape.GetNumDimensions() == 1)
684 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
691 for (
unsigned int i = 0; i < unsignedAxis; ++i)
693 if (outputShape[i] != inputShape[i])
699 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
701 if (outputShape[i - 1] != inputShape[i])
711 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
713 ValidateNumInputs(workloadInfo, descriptorName, 1);
714 ValidateNumOutputs(workloadInfo, descriptorName, 1);
719 std::vector<DataType> supportedTypes =
729 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
730 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
731 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
736 const std::string descriptorName{
"SplitterQueueDescriptor"};
738 ValidateNumInputs(workloadInfo, descriptorName, 1);
741 std::vector<DataType> supportedTypes =
757 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
759 const std::string outputName =
"output_" + std::to_string(i);
760 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
771 descriptorName +
": Number of split windows " 772 "has to match number of workloadInfo.m_OutputTensorInfos. " 773 "Number of windows: " +
774 to_string(m_ViewOrigins.size()) +
775 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
780 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
787 "have the same dimensionality as the input tensor. " 788 "Window origin (index: " +
789 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
790 " dimensions, the input " 792 to_string(inputDims) +
" dimensions.");
794 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
800 "be smaller or equal than the size of the input in that coord.");
808 const std::string descriptorName{
"ConcatQueueDescriptor"};
810 ValidateNumOutputs(workloadInfo, descriptorName, 1);
830 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
835 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
843 descriptorName +
": Number of split windows " 844 "has to match number of workloadInfo.m_InputTensorInfos. " 845 "Number of windows: " +
846 to_string(m_ViewOrigins.size()) +
847 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
852 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
856 if (e.
m_Origin.size() != outputDims)
859 "have the same dimensionality as the output tensor. " 860 "Window origin (index: " +
861 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
862 " dimensions, the output " 864 to_string(outputDims) +
" dimensions.");
867 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
873 "be smaller or equal than the size of the output in that coord.");
879 std::vector<DataType> supportedTypes =
895 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
897 const std::string inputName =
"input_" + std::to_string(i);
898 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
904 const std::string descriptorName{
"StackQueueDescriptor"};
906 ValidateNumOutputs(workloadInfo, descriptorName, 1);
914 const TensorShape& inputShape = m_Parameters.m_InputShape;
933 "than the number of input dimensions.");
938 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
940 if (outputShape[i] != inputShape[i])
943 "match shape inferred from input tensor.");
947 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
950 "match shape inferred from input tensor.");
953 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
955 if (outputShape[i] != inputShape[i-1])
958 "match shape inferred from input tensor.");
968 std::vector<DataType> supportedTypes =
980 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
988 "input_" + std::to_string(i));
1000 const std::string descriptorName{
"FillQueueDescriptor"};
1002 ValidateNumInputs(workloadInfo, descriptorName, 1);
1003 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1008 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 1,
"input");
1010 std::vector<DataType> supportedTypes =
1018 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1023 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1025 ValidateNumInputs(workloadInfo, descriptorName, 1);
1026 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1031 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1038 ValidatePointer(m_Weight, descriptorName,
"weight");
1040 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1041 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 2,
"weight");
1043 if (m_Parameters.m_BiasEnabled)
1045 ValidatePointer(m_Bias, descriptorName,
"bias");
1048 const TensorInfo& biasTensorInfo = m_Bias->GetTensorInfo();
1049 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1052 ValidateTensorNumDimensions(biasTensorInfo, descriptorName, 1,
"bias");
1056 std::vector<DataType> supportedTypes =
1066 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1074 "for BFloat16 input.");
1079 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1085 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1087 ValidateNumInputs(workloadInfo, descriptorName, 1);
1088 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1094 std::vector<DataType> supportedTypes =
1104 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1106 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1108 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1113 const std::string descriptorName{
"AdditionQueueDescriptor"};
1115 ValidateNumInputs(workloadInfo, descriptorName, 2);
1116 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1122 std::vector<DataType> supportedTypes =
1133 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1134 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1135 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1137 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1138 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1140 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1150 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1152 ValidateNumInputs(workloadInfo, descriptorName, 2);
1153 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1159 std::vector<DataType> supportedTypes =
1170 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1171 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1172 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1174 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1175 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1177 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1187 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1189 ValidateNumInputs(workloadInfo, descriptorName, 1);
1190 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1195 std::vector<DataType> supportedTypes =
1205 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1206 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1208 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1209 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1211 ValidatePointer(m_Mean, descriptorName,
"mean");
1212 ValidatePointer(m_Variance, descriptorName,
"variance");
1213 ValidatePointer(m_Beta, descriptorName,
"beta");
1214 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1216 const TensorInfo& mean = m_Mean->GetTensorInfo();
1217 const TensorInfo& variance = m_Variance->GetTensorInfo();
1218 const TensorInfo& beta = m_Beta->GetTensorInfo();
1219 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1221 ValidateTensorNumDimensions(mean, descriptorName, 1,
"mean");
1222 ValidateTensorNumDimensions(variance, descriptorName, 1,
"variance");
1223 ValidateTensorNumDimensions(beta, descriptorName, 1,
"beta");
1224 ValidateTensorNumDimensions(gamma, descriptorName, 1,
"gamma");
1226 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1227 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1228 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1233 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1235 ValidateNumInputs(workloadInfo, descriptorName, 1);
1236 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1241 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1242 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1244 ValidatePointer(m_Weight, descriptorName,
"weight");
1246 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1247 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1249 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1252 if (m_Parameters.m_BiasEnabled)
1254 ValidatePointer(m_Bias, descriptorName,
"bias");
1256 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1260 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1263 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1266 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1267 "cannot be either negative or 0.",
1268 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1271 ValidatePerAxisQuantization(inputTensorInfo,
1274 optionalBiasTensorInfo,
1277 std::vector<DataType> supportedTypes =
1288 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1296 "for BFloat16 input.");
1301 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1307 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1309 ValidateNumInputs(workloadInfo, descriptorName, 1);
1310 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1315 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1316 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1318 ValidatePointer(m_Weight, descriptorName,
"weight");
1320 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1321 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1323 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1326 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) " 1327 "cannot be smaller than 1.",
1328 descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
1331 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1334 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1335 "cannot be either negative or 0.",
1336 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1339 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1343 const unsigned int numWeightChannelMultiplier = weightTensorInfo.
GetShape()[0];
1344 const unsigned int numWeightInputChannels = weightTensorInfo.
GetShape()[1];
1345 const unsigned int numWeightOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1346 if (numWeightChannelMultiplier * numWeightInputChannels != numWeightOutputChannels)
1349 "{0}: output_channels (provided {1}) should be equal to input_channels (provided {2}) " 1350 "multiplied by channel_multiplier (provided {3}).",
1351 descriptorName, numWeightOutputChannels, numWeightInputChannels, numWeightChannelMultiplier));
1354 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1357 if (m_Parameters.m_BiasEnabled)
1359 ValidatePointer(m_Bias, descriptorName,
"bias");
1361 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1364 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1367 ValidatePerAxisQuantization(inputTensorInfo,
1370 optionalBiasTensorInfo,
1373 std::vector<DataType> supportedTypes =
1383 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1384 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1389 const std::string descriptorName{
"PermuteQueueDescriptor"};
1391 ValidateNumInputs(workloadInfo, descriptorName, 1);
1392 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1399 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
1400 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
1402 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1404 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1407 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1408 "must match dst dimension " + to_string(mapping[i]) +
1409 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1413 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1418 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1420 ValidateNumInputs(workloadInfo, descriptorName, 1);
1421 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1426 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1427 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1429 std::vector<DataType> supportedTypes =
1439 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1440 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1445 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1447 ValidateNumInputs(workloadInfo, descriptorName, 1);
1448 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1453 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1454 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1456 std::vector<DataType> supportedTypes =
1466 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1467 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1470 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1471 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1472 if (inputBatchSize != outputBatchSize)
1475 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1476 descriptorName, inputBatchSize, outputBatchSize));
1482 if (inputChannelCount != outputChannelCount)
1485 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1486 descriptorName, inputChannelCount, outputChannelCount));
1492 const std::string descriptorName{
"ResizeQueueDescriptor"};
1494 ValidateNumInputs(workloadInfo, descriptorName, 1);
1495 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1500 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1501 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1503 std::vector<DataType> supportedTypes =
1513 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1514 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1517 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1518 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1519 if (inputBatchSize != outputBatchSize)
1522 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1523 descriptorName, inputBatchSize, outputBatchSize));
1529 if (inputChannelCount != outputChannelCount)
1532 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1533 descriptorName, inputChannelCount, outputChannelCount));
1539 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1541 ValidateNumInputs(workloadInfo, descriptorName, 1);
1542 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1547 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1548 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1550 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1552 if (m_Parameters.m_Min > m_Parameters.m_Max)
1560 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1562 ValidateNumInputs(workloadInfo, descriptorName, 1);
1563 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1573 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1576 std::vector<DataType> supportedTypes =
1583 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1584 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1589 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1591 ValidateNumInputs(workloadInfo, descriptorName, 1);
1592 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1602 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1605 std::vector<DataType> supportedTypes =
1615 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1616 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1621 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1623 ValidateNumInputs(workloadInfo, descriptorName, 1);
1624 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1629 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1631 std::vector<DataType> supportedTypes =
1638 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1639 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1644 const std::string descriptorName{
"ConstantQueueDescriptor"};
1646 ValidateNumInputs(workloadInfo, descriptorName, 0);
1647 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1655 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1658 std::vector<DataType> supportedTypes =
1670 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1675 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1677 ValidateNumInputs(workloadInfo, descriptorName, 1);
1678 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1683 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1686 std::vector<DataType> supportedTypes =
1698 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1699 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1704 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1706 ValidateNumInputs(workloadInfo, descriptorName, 1);
1707 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1712 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1713 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1715 if (m_Parameters.m_BlockShape.size() != 2)
1720 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1723 "dimensions as Block Shape.");
1728 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1729 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1733 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1734 widthPad.first + widthPad.second;
1735 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1736 heightPad.first + heightPad.second;
1738 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1740 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1742 if (numOutputElements != numInputElements)
1745 to_string(numInputElements) +
" after padding but output tensor has " +
1746 to_string(numOutputElements) +
" elements.");
1749 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1752 "divisible by Block Shape in all spatial dimensions");
1755 std::vector<DataType> supportedTypes =
1765 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1766 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1771 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1773 ValidateNumInputs(workloadInfo, descriptorName, 1);
1774 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1779 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1780 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1782 std::vector<DataType> supportedTypes =
1792 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1793 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1795 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1797 if (m_Parameters.m_BlockSize == 0)
1803 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1808 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1811 "by block size in all spatial dimensions");
1815 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1818 "must be divisible by the square of block size." );
1824 const std::string descriptorName{
"FloorQueueDescriptor"};
1826 ValidateNumInputs(workloadInfo, descriptorName, 1);
1827 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1832 std::vector<DataType> supportedTypes =
1840 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1842 if (inputTensorInfo != outputTensorInfo)
1852 const std::string descriptorName{
"LstmQueueDescriptor"};
1864 std::vector<DataType> supportedTypes =
1873 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1882 "input_" + std::to_string(i));
1889 "LstmQueueDescriptor",
1891 "output_" + std::to_string(i));
1897 if (m_Parameters.m_ClippingThresCell < 0.0f)
1901 if (m_Parameters.m_ClippingThresProj < 0.0f)
1910 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
1911 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
1912 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
1913 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
1916 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
1917 descriptorName +
" input_0");
1919 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
1920 descriptorName +
" input_1");
1922 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
1923 descriptorName +
" input_2");
1925 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
1926 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
1927 descriptorName +
" output_0");
1930 descriptorName +
" output_1");
1933 descriptorName +
" output_2");
1936 descriptorName +
" output_3");
1940 if ( m_InputToInputWeights )
1942 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
1943 (n_cell * n_input),
"InputLayerNormWeights");
1946 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
1947 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
1948 (n_cell * n_input),
"InputToForgetWeights");
1950 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
1951 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
1952 (n_cell * n_input),
"InputToCellWeights");
1954 if ( m_RecurrentToInputWeights )
1956 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
1957 (n_cell * n_output),
"RecurrentToInputWeights");
1960 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
1961 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
1962 (n_cell * n_output),
"RecurrentToForgetWeights");
1964 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
1965 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
1966 (n_cell * n_output),
"RecurrentToCellWeights");
1970 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
1971 !m_Parameters.m_CifgEnabled) ||
1972 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
1973 m_Parameters.m_CifgEnabled));
1974 if (!cifg_weights_all_or_none)
1977 "RecurrentToInputWeights must either both be present (regular LSTM) " 1978 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 1982 if ( m_CellToInputWeights )
1984 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
1985 n_cell,
"CellToInputWeights");
1987 if ( m_CellToForgetWeights )
1989 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
1990 n_cell,
"CellToForgetWeights");
1992 if ( m_CellToOutputWeights )
1994 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
1995 n_cell,
"CellToOutputWeights");
1999 bool peephole_weights_all_or_none =
2000 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
2001 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
2002 || ( !m_CellToInputWeights && !m_CellToForgetWeights
2003 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
2004 if (!peephole_weights_all_or_none)
2010 if (m_Parameters.m_CifgEnabled)
2012 if (m_InputGateBias)
2019 if (!m_InputGateBias)
2022 "must be present.");
2024 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
2025 n_cell,
"InputGateBias");
2028 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2029 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
2031 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2032 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
2034 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2035 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
2037 if (m_ProjectionWeights)
2039 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
2040 (n_cell * n_output),
"ProjectionWeights");
2042 if (m_ProjectionBias)
2044 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
2051 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2052 !m_Parameters.m_ProjectionEnabled)
2053 || (m_ProjectionWeights && !m_ProjectionBias &&
2054 m_Parameters.m_ProjectionEnabled)
2055 || (m_ProjectionWeights && m_ProjectionBias &&
2056 m_Parameters.m_ProjectionEnabled));
2057 if (!projecton_tensors_consistent)
2066 if (m_InputLayerNormWeights)
2068 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2070 if (m_ForgetLayerNormWeights)
2072 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2074 if (m_CellLayerNormWeights)
2076 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2078 if (m_OutputLayerNormWeights)
2080 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2083 if (m_Parameters.m_LayerNormEnabled)
2085 if (!m_Parameters.m_CifgEnabled)
2087 if (!m_InputLayerNormWeights)
2090 "disabled but InputLayerNormWeights are not present");
2092 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2093 1, n_cell,
"InputLayerNormWeights");
2095 else if (m_InputLayerNormWeights)
2101 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2102 "ForgetLayerNormWeights");
2103 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2105 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2106 "OutputLayerNormWeights");
2107 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2109 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2110 "CellLayerNormWeights");
2111 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2113 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2116 "normalisation weights are present.");
2122 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2124 ValidateNumInputs(workloadInfo, descriptorName, 1);
2125 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2140 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2145 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2147 ValidateNumInputs(workloadInfo, descriptorName, 1);
2148 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2163 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2168 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2170 ValidateNumInputs(workloadInfo, descriptorName, 1);
2171 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2186 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2191 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2193 ValidateNumInputs(workloadInfo, descriptorName, 1);
2194 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2209 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2214 const std::string descriptorName{
"DivisionQueueDescriptor"};
2216 ValidateNumInputs(workloadInfo, descriptorName, 2);
2217 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2223 std::vector<DataType> supportedTypes =
2234 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2235 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2236 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2238 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2248 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2250 ValidateNumInputs(workloadInfo, descriptorName, 2);
2251 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2257 std::vector<DataType> supportedTypes =
2268 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2269 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2270 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2272 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2282 const std::string descriptorName{
"MaximumQueueDescriptor"};
2284 ValidateNumInputs(workloadInfo, descriptorName, 2);
2285 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2291 std::vector<DataType> supportedTypes =
2302 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2303 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2304 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2306 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2316 const std::string descriptorName{
"MeanQueueDescriptor"};
2318 ValidateNumInputs(workloadInfo, descriptorName, 1);
2319 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2324 std::vector<DataType> supportedTypes =
2336 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2337 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2339 if (m_Parameters.m_KeepDims)
2341 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2343 else if (m_Parameters.m_Axis.empty())
2345 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2349 unsigned int outputDim =
2351 ValidateTensorNumDimensions(outputTensorInfo,
2353 outputDim > 0 ? outputDim : 1,
2360 const std::string descriptorName{
"PadQueueDescriptor"};
2362 ValidateNumInputs(workloadInfo, descriptorName, 1);
2363 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2369 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2374 "as there are dimensions in the input tensor that is " +
2376 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2382 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2384 ValidateNumInputs(workloadInfo, descriptorName, 1);
2385 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2390 std::vector<DataType> supportedTypes =
2401 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2411 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2413 ValidateNumInputs(workloadInfo, descriptorName, 1);
2414 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2419 std::vector<DataType> supportedTypes =
2429 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2430 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2435 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2437 ValidateNumInputs(workloadInfo, descriptorName, 1);
2438 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2443 std::vector<DataType> supportedTypes =
2453 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2454 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2456 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2465 if (m_Parameters.m_Begin.size() != rank)
2470 if (m_Parameters.m_End.size() != rank)
2475 if (m_Parameters.m_Stride.size() != rank)
2481 for (
auto& stride : m_Parameters.m_Stride)
2492 const std::string descriptorName{
"MinimumQueueDescriptor"};
2494 ValidateNumInputs(workloadInfo, descriptorName, 2);
2495 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2501 std::vector<DataType> supportedTypes =
2512 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2513 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2514 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2516 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2526 const std::string descriptorName{
"DebugQueueDescriptor"};
2528 ValidateNumInputs(workloadInfo, descriptorName, 1);
2529 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2534 const std::string descriptorName{
"EqualQueueDescriptor"};
2536 ValidateNumInputs(workloadInfo, descriptorName, 2);
2537 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2543 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2558 const std::string descriptorName{
"GreaterQueueDescriptor"};
2560 ValidateNumInputs(workloadInfo, descriptorName, 2);
2561 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2567 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2582 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2584 ValidateNumInputs(workloadInfo, descriptorName, 1);
2585 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2590 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2592 std::vector<DataType> supportedTypes =
2602 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2603 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2608 const std::string descriptorName{
"GatherQueueDescriptor"};
2610 ValidateNumInputs(workloadInfo, descriptorName, 2);
2611 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2622 std::vector<DataType> supportedTypes =
2633 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2635 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2638 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2643 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2645 ValidateNumInputs(workloadInfo, descriptorName, 2);
2653 if (m_Anchors ==
nullptr)
2667 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2668 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2669 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2671 const std::vector<DataType> supportedInputTypes =
2681 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2682 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2683 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2685 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2686 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2687 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2688 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2691 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2692 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2693 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2694 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2696 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2699 "must be positive and less than or equal to 1.");
2702 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2705 "should be equal to number of classes + 1.");
2711 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2713 ValidateNumInputs(workloadInfo, descriptorName, 1);
2714 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2724 std::vector<DataType> supportedTypes =
2731 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2736 const std::string& descriptorName{
"MergeQueueDescriptor"};
2738 ValidateNumInputs(workloadInfo, descriptorName, 2);
2739 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2745 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2746 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2748 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2749 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2754 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2756 ValidateNumInputs(workloadInfo, descriptorName, 2);
2757 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2765 std::vector<DataType> supportedTypes =
2774 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2775 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2777 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2778 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2780 ValidateTensorShapesMatch(inputTensorInfo0,
2786 ValidateTensorShapesMatch(inputTensorInfo0,
2800 const std::string& descriptorName{
"PreluQueueDescriptor"};
2802 ValidateNumInputs(workloadInfo, descriptorName, 2);
2803 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2809 std::vector<DataType> supportedTypes
2819 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2820 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2822 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2824 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2825 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2827 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2837 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2839 ValidateNumInputs(workloadInfo, descriptorName, 1);
2840 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2845 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2846 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2848 ValidatePointer(m_Weight, descriptorName,
"weight");
2850 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2851 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2853 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2856 if (m_Parameters.m_BiasEnabled)
2858 ValidatePointer(m_Bias, descriptorName,
"bias");
2860 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
2864 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2867 ValidatePerAxisQuantization(inputTensorInfo,
2870 optionalBiasTensorInfo,
2873 std::vector<DataType> supportedTypes =
2883 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2884 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2889 const std::string descriptorName{
"TransposeQueueDescriptor"};
2891 ValidateNumInputs(workloadInfo, descriptorName, 1);
2892 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2899 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
2900 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
2902 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
2904 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
2907 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
2908 "must match dst dimension " + to_string(i) +
2909 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
2913 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2918 const std::string descriptorName{
"QLstmQueueDescriptor"};
2921 ValidateNumInputs(workloadInfo, descriptorName, 3);
2922 ValidateNumOutputs(workloadInfo, descriptorName, 3);
2934 std::vector<DataType> inputOutputSupportedTypes =
2939 std::vector<DataType> cellStateSupportedTypes =
2944 std::vector<DataType> weightsSupportedTypes =
2949 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
2954 std::vector<DataType> biasSupportedTypes =
2960 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
2961 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
2962 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
2964 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
2965 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
2966 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
2969 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
2970 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
2971 "outputStateIn",
"outputStateOut");
2972 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
2975 const uint32_t numBatches = inputInfo.GetShape()[0];
2976 const uint32_t inputSize = inputInfo.GetShape()[1];
2977 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
2978 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
2981 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
2982 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
2983 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
2985 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
2986 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
2987 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
2990 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
2991 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
2992 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
2994 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
2995 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
2996 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
2998 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
2999 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3000 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
3002 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3003 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3004 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
3005 " RecurrentToForgetWeights");
3007 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3008 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3009 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3011 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3012 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3013 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3016 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3018 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3019 "inputToForgetWeights",
"inputToCellWeights");
3020 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3021 "inputToForgetWeights",
"inputToOutputWeights");
3023 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3024 "inputToForgetWeights",
"recurrentToForgeteights");
3025 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3026 "inputToForgetWeights",
"recurrentToCellWeights");
3027 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3028 "inputToForgetWeights",
"recurrentToOutputWeights");
3031 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3032 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3033 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
3035 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3036 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3037 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
3039 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3040 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3041 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
3044 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3046 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3047 "forgetGateBias",
"cellBias");
3048 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3049 "forgetGateBias",
"outputGateBias");
3052 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3053 !m_Parameters.m_CifgEnabled) ||
3054 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3055 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3057 if (!allCifgParamsPresentOrNot)
3060 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3061 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3062 "set appropriately.");
3065 if (!m_Parameters.m_CifgEnabled)
3068 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3069 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3071 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3072 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3073 " RecurrentToInputWeights");
3075 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3076 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3079 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3080 "inputToForgetWeights",
"inputToInputWeights");
3081 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3082 "inputToForgetWeights",
"recurrentToInputWeights");
3083 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3084 "forgetGateBias",
"inputGateBias");
3088 bool allPeepholeWeightsPresentOrNot =
3089 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3090 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3091 || (!m_CellToInputWeights && !m_CellToForgetWeights
3092 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3094 if (!allPeepholeWeightsPresentOrNot)
3097 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3098 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3099 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3103 if (m_Parameters.m_PeepholeEnabled)
3105 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3106 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3107 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3109 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3110 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3111 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3112 "cellToForgetWeight",
"cellToOutputWeights");
3114 if (!m_Parameters.m_CifgEnabled)
3116 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3117 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3118 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3119 "cellToForgetWeights",
"cellToInputWeights");
3124 bool allLayerNormWeightsPresentOrNot =
3125 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3126 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3127 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3128 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3130 if (!allLayerNormWeightsPresentOrNot)
3133 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3134 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3135 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3136 "only be present when Layer Norm is enabled and CIFG is disabled. " 3137 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3140 if (m_Parameters.m_LayerNormEnabled)
3142 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3143 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3144 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3146 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3147 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3148 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3149 "forgetLayerNormWeights",
"cellLayerNormWeights");
3151 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3152 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3153 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3154 "forgetLayerNormWeights",
"outputLayerNormWeights");
3156 if (!m_Parameters.m_CifgEnabled)
3158 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3159 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3160 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3161 "forgetLayerNormWeights",
"inputLayerNormWeights");
3166 bool correctProjectionTensorsPresent =
3167 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3168 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3169 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3171 if (!correctProjectionTensorsPresent)
3174 ": If projection is enabled, ProjectionWeights should be present and " 3175 "ProjectionBias is optional. If projection is disabled, neither " 3176 "ProjectionWeights nor ProjectionBias should be present.");
3179 if (m_Parameters.m_ProjectionEnabled)
3181 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3182 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3183 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3185 if (m_ProjectionBias)
3187 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3188 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3189 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3193 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3194 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3196 ": If projection is disabled, output quantization info (scale, offset) " 3197 "should match HiddenStateScale and HiddenStateZeroPoint.");
3204 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3207 ValidateNumInputs(workloadInfo, descriptorName, 3);
3208 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3218 std::vector<DataType> inputOutputSupportedTypes =
3223 std::vector<DataType> cellStateSupportedTypes =
3228 std::vector<DataType> weightsSupportedTypes =
3233 std::vector<DataType> biasSupportedTypes =
3239 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3240 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3241 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3243 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3244 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3247 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3248 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3249 "outputStateIn",
"outputStateOut");
3250 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3253 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3254 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3255 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3258 const uint32_t numBatches = inputInfo.GetShape()[0];
3259 const uint32_t inputSize = inputInfo.GetShape()[1];
3260 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3263 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3264 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3265 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3266 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3267 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3270 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3271 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3272 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3274 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3275 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3276 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3278 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3279 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3280 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3282 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3283 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3284 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3286 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3287 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3288 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3290 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3291 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3292 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3293 " RecurrentToForgetWeights");
3295 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3296 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3297 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3299 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3300 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3301 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3304 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3306 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3307 "inputToInputWeights",
"inputToForgetWeights");
3308 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3309 "inputToInputWeights",
"inputToCellWeights");
3310 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3311 "inputToInputWeights",
"inputToOutputWeights");
3313 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3314 "inputToInputWeights",
"recurrentToInputWeights");
3315 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3316 "inputToInputWeights",
"recurrentToForgeteights");
3317 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3318 "inputToInputWeights",
"recurrentToCellWeights");
3319 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3320 "inputToInputWeights",
"recurrentToOutputWeights");
3323 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3324 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3325 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3326 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3327 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3328 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3330 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3331 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3332 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3333 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3334 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3335 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3336 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3337 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3340 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3341 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3342 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3344 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3345 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3346 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3348 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3349 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3350 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3352 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3353 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3354 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3357 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3359 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3360 "inputGateBias",
"forgetGateBias");
3361 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3362 "inputGateBias",
"cellBias");
3363 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3364 "inputGateBias",
"outputGateBias");
3367 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3368 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3369 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3370 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3375 const std::string descriptorName{
"AbsQueueDescriptor"};
3377 ValidateNumInputs(workloadInfo, descriptorName, 1);
3378 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3383 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3385 std::vector<DataType> supportedTypes =
3396 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3397 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3402 const std::string descriptorName{
"SliceQueueDescriptor"};
3404 ValidateNumInputs(workloadInfo, descriptorName, 1);
3405 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3410 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3418 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3421 if (m_Parameters.m_Begin.size() != rank)
3424 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3426 if (m_Parameters.m_Size.size() != rank)
3429 ": Length of size descriptor must equal rank " + std::to_string(rank));
3434 for (
unsigned int i = 0u; i < rank; ++i)
3436 if (m_Parameters.m_Size[i] != outputShape[i])
3445 for(
unsigned int i = 0u; i < rank; ++i)
3447 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3450 std::to_string(i) +
" exceeds input size.");
3457 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3459 ValidateNumInputs(workloadInfo, descriptorName, 1);
3460 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3465 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3466 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3468 std::vector<DataType> supportedTypes =
3478 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3479 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3481 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3483 if (m_Parameters.m_BlockSize == 0)
3489 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3494 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3497 "must be divisible by block size.");
3501 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3504 "must be divisible by the square of block size." );
3510 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3512 ValidateNumInputs(workloadInfo, descriptorName, 2);
3513 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3519 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3534 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3536 ValidateNumInputs(workloadInfo, descriptorName, 1);
3537 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3542 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3544 std::vector<DataType> supportedTypes =
3555 std::vector<DataType> logicalSupportedTypes =
3562 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3566 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3570 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3575 const std::string descriptorName{
"RankQueueDescriptor"};
3577 ValidateNumInputs(workloadInfo, descriptorName, 1);
3578 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3583 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
3584 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3586 std::vector<DataType> supportedTypes =
3598 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3599 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3604 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3606 ValidateNumInputs(workloadInfo, descriptorName, 2);
3607 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3613 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3638 const std::string descriptorName{
"ReduceQueueDescriptor"};
3640 ValidateNumInputs(workloadInfo, descriptorName, 1);
3641 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3646 std::vector<DataType> supportedTypes =
3657 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3658 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool HasPerAxisQuantization() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
Optional< unsigned int > GetQuantizationDim() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32)
void ValidateInputsOutputs(const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const
Copyright (c) 2021 ARM Limited and Contributors.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< float > GetQuantizationScales() const
bool HasMultipleQuantizationScales() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetHeightIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
constexpr const char * GetDataTypeName(DataType dataType)
constexpr bool IsQuantized8BitType(DataType dataType)
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_InputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_NO_DEPRECATE_WARN_END
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_ASSERT_MSG(COND, MSG)
void Validate(const WorkloadInfo &workloadInfo) const
int32_t GetQuantizationOffset() const
float GetQuantizationScale() const
Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout...
DataType GetDataType() const
bool has_value() const noexcept
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetUnsignedAxis(const unsigned int inputDimension, const int axis)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_OutputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
DataType GetBiasDataType(DataType inputDataType)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< ITensorHandle * > m_Outputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
Function that returns the tensor rank.
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Contains information about inputs and outputs to a layer.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< ITensorHandle * > m_Inputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
unsigned int GetChannelsIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumElements() const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< unsigned int > m_Origin