20 #include <fmt/format.h>
30 switch (inputDataType)
32 case DataType::Float16:
33 return DataType::Float16;
35 case DataType::Float32:
36 return DataType::Float32;
37 case DataType::QAsymmS8:
38 case DataType::QAsymmU8:
39 case DataType::QSymmS8:
40 case DataType::QSymmS16:
41 return DataType::Signed32;
53 std::string to_string(T value)
55 std::ostringstream os;
61 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
66 paramName +
" parameter must be set.");
71 void ValidateTensorShapesMatch(
const TensorInfo& first,
73 std::string
const& descName,
74 std::string
const& firstName,
75 std::string
const& secondName)
80 + firstName +
" & " + secondName +
" must have identical shapes");
85 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
90 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
96 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
101 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
109 void ValidateTensorNumElements(
const TensorInfo& tensor,
110 std::string
const& descName,
111 unsigned int numElements,
112 std::string
const& tensorName)
118 tensorName +
" tensor.");
124 const std::string& descName, std::string
const& tensorName)
133 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
138 ": Expected data type which supports per-axis quantization scheme but got " +
144 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
146 const std::string& descName,
147 std::string
const& firstName,
148 std::string
const& secondName)
160 if (firstDataType != secondDataType)
163 " must be of the same quantized type, " +
171 " must have the same quantization space, " +
180 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
182 const std::string& descName)
196 if (weightScales.size() != biasScales.size())
198 std::stringstream msg;
199 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, "
200 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
201 <<
", biases=" << biasScales.size();
208 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
209 unsigned int numExpected,
210 const std::string& descName,
211 const std::string& varName)
213 if (vec.empty() && numExpected > 0)
218 for (
unsigned int i = 0; i < numExpected; ++i)
228 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
231 std::string
const& descName,
232 std::string
const& firstName,
233 std::string
const& secondName)
241 + firstName +
" & " + secondName
242 +
" must have the same number of dimensions in order to be broadcasted");
245 std::vector<uint32_t> outputDims(numDims, 0u);
246 for (uint32_t i = 0; i < numDims; i++)
249 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
250 if (dimsNotEqual && dimsNotOne)
256 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
257 if (broadcastShape != output.
GetShape())
260 + firstName +
" & " + secondName
261 +
" does not match the output shape");
266 void ValidateDataTypes(
const TensorInfo& info,
267 const std::vector<armnn::DataType>& supportedTypes,
268 std::string
const& descName)
270 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(),
info.GetDataType());
271 if (iterator == supportedTypes.end())
274 " is not supported.");
279 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
281 std::string
const& descName,
282 std::string
const& firstName,
283 std::string
const& secondName)
288 " must have identical data types.");
293 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
295 std::string
const& descName,
296 std::string
const& firstName,
297 std::string
const& secondName)
302 " must have the same number of elements.");
306 void ValidateWeightDataType(
const TensorInfo& inputInfo,
308 const std::string& descName)
313 const std::vector<DataType> validTypes =
320 ValidateDataTypes(weightInfo, validTypes, descName);
324 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
328 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
329 const std::string& descName,
330 const std::string& tensorName)
336 "not set on tensor {1}.", descName, tensorName));
340 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
341 const std::string& descName,
342 const std::string& tensorName)
345 if (quantizationOffset != 0)
348 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
349 descName, tensorName, quantizationOffset));
353 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
357 const std::string& descName)
364 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
366 if (!canHavePerAxisQuantization)
369 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support "
370 "per-axis quantization.", descName,
"weight"));
374 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
375 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
376 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
384 "{}: Per-axis quantization parameters not set on bias tensor, "
385 "despite being set on weight tensor.", descName));
388 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
389 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
390 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
399 std::string
const& descName,
400 unsigned int numDimensions,
401 std::string
const& tensorName)
const
408 unsigned int squeezedDims = 0;
417 if (tensor.
GetNumDimensions() < numDimensions || squeezedDims > numDimensions)
421 tensorName +
" tensor.");
430 tensorName +
" tensor.");
437 unsigned int numDimension,
438 unsigned int numElements,
439 std::string
const& tensorName)
const
441 const std::string functionName{
"ValidateTensorNumDimNumElem"};
443 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
448 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const
450 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
451 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
457 const std::string descriptorName{
"MapQueueDescriptor"};
459 ValidateNumInputs(workloadInfo, descriptorName, 1);
460 ValidateNumOutputs(workloadInfo, descriptorName, 0);
462 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
467 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
475 const std::string descriptorName{
"UnmapQueueDescriptor"};
477 ValidateNumInputs(workloadInfo, descriptorName, 1);
478 ValidateNumOutputs(workloadInfo, descriptorName, 0);
480 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
485 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
493 const std::string descriptorName{
"MemCopyQueueDescriptor"};
495 ValidateNumInputs(workloadInfo, descriptorName, 1);
496 ValidateNumOutputs(workloadInfo, descriptorName , 1);
501 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
502 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
507 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
511 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
516 "{0}: Invalid NULL input {1}.", descriptorName, i));
529 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
530 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
542 "Number of input infos ({0}) does not match the number of output infos ({1})",
552 "Number of elements for tensor input and output {} does not match", i ));
564 "Number of inputs ({0}) does not match the number of outputs ({1})",
568 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
585 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
606 const std::string descriptorName{
"ActivationQueueDescriptor"};
608 ValidateNumInputs(workloadInfo, descriptorName, 1);
609 ValidateNumOutputs(workloadInfo, descriptorName, 1);
614 std::vector<DataType> supportedTypes =
624 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
625 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
626 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
631 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
633 ValidateNumInputs(workloadInfo, descriptorName, 1);
634 ValidateNumOutputs(workloadInfo, descriptorName, 1);
645 std::vector<DataType> supportedInputTypes =
657 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
659 auto inputShape = inputTensorInfo.
GetShape();
660 auto outputShape = outputTensorInfo.
GetShape();
665 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
668 if (inputShape.GetNumDimensions() == 1)
670 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
677 for (
unsigned int i = 0; i < unsignedAxis; ++i)
679 if (outputShape[i] != inputShape[i])
685 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
687 if (outputShape[i - 1] != inputShape[i])
697 const std::string descriptorName{
"CastQueueDescriptor"};
699 ValidateNumInputs(workloadInfo, descriptorName, 1);
700 ValidateNumOutputs(workloadInfo, descriptorName, 1);
705 std::vector<DataType> supportedTypes =
719 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
720 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
725 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
727 ValidateNumInputs(workloadInfo, descriptorName, 1);
728 ValidateNumOutputs(workloadInfo, descriptorName, 1);
733 std::vector<DataType> supportedTypes =
743 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
744 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
745 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
750 const std::string descriptorName{
"SplitterQueueDescriptor"};
752 ValidateNumInputs(workloadInfo, descriptorName, 1);
755 std::vector<DataType> supportedTypes =
771 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
773 const std::string outputName =
"output_" + std::to_string(i);
774 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
785 descriptorName +
": Number of split windows "
786 "has to match number of workloadInfo.m_OutputTensorInfos. "
787 "Number of windows: " +
789 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
801 "have the same dimensionality as the input tensor. "
802 "Window origin (index: " +
803 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
804 " dimensions, the input "
806 to_string(inputDims) +
" dimensions.");
808 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
814 "be smaller or equal than the size of the input in that coord.");
822 const std::string descriptorName{
"ConcatQueueDescriptor"};
824 ValidateNumOutputs(workloadInfo, descriptorName, 1);
857 descriptorName +
": Number of split windows "
858 "has to match number of workloadInfo.m_InputTensorInfos. "
859 "Number of windows: " +
861 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
870 if (e.
m_Origin.size() != outputDims)
873 "have the same dimensionality as the output tensor. "
874 "Window origin (index: " +
875 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
876 " dimensions, the output "
878 to_string(outputDims) +
" dimensions.");
881 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
887 "be smaller or equal than the size of the output in that coord.");
893 std::vector<DataType> supportedTypes =
909 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
911 const std::string inputName =
"input_" + std::to_string(i);
912 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
918 const std::string descriptorName{
"StackQueueDescriptor"};
920 ValidateNumOutputs(workloadInfo, descriptorName, 1);
947 "than the number of input dimensions.");
954 if (outputShape[i] != inputShape[i])
957 "match shape inferred from input tensor.");
964 "match shape inferred from input tensor.");
969 if (outputShape[i] != inputShape[i-1])
972 "match shape inferred from input tensor.");
982 std::vector<DataType> supportedTypes =
994 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1002 "input_" + std::to_string(i));
1014 const std::string descriptorName{
"FillQueueDescriptor"};
1016 ValidateNumInputs(workloadInfo, descriptorName, 1);
1017 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1024 std::vector<DataType> supportedTypes =
1032 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1037 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1039 uint32_t numInputs = 2;
1045 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1046 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1065 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1071 std::vector<DataType> supportedTypes =
1081 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1089 "for BFloat16 input.");
1094 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1105 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1107 ValidateNumInputs(workloadInfo, descriptorName, 1);
1108 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1114 std::vector<DataType> supportedTypes =
1124 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1126 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1128 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1133 const std::string descriptorName{
"AdditionQueueDescriptor"};
1135 ValidateNumInputs(workloadInfo, descriptorName, 2);
1136 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1142 std::vector<DataType> supportedTypes =
1153 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1154 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1155 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1157 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1158 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1160 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1170 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1172 ValidateNumInputs(workloadInfo, descriptorName, 2);
1173 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1179 std::vector<DataType> supportedTypes =
1190 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1191 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1192 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1194 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1195 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1197 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1207 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1209 ValidateNumInputs(workloadInfo, descriptorName, 1);
1210 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1215 std::vector<DataType> supportedTypes =
1225 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1226 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1228 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1229 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1231 ValidatePointer(
m_Mean, descriptorName,
"mean");
1232 ValidatePointer(
m_Variance, descriptorName,
"variance");
1233 ValidatePointer(
m_Beta, descriptorName,
"beta");
1234 ValidatePointer(
m_Gamma, descriptorName,
"gamma");
1246 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1247 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1248 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1253 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1255 uint32_t numInputs = 2;
1261 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1262 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1274 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1279 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1283 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1289 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1290 "cannot be either negative or 0.",
1294 ValidatePerAxisQuantization(inputTensorInfo,
1297 optionalBiasTensorInfo,
1300 std::vector<DataType> supportedTypes =
1311 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1319 "for BFloat16 input.");
1324 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1330 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1332 uint32_t numInputs = 2;
1337 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1338 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1349 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1354 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1358 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1364 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})"
1365 "cannot be either negative or 0.",
1369 ValidatePerAxisQuantization(inputTensorInfo,
1372 optionalBiasTensorInfo,
1375 std::vector<DataType> supportedTypes =
1386 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1387 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1392 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1394 uint32_t numInputs = 2;
1400 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1401 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1415 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) "
1416 "cannot be smaller than 1.",
1423 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1424 "cannot be either negative or 0.",
1428 if (weightTensorInfo.
GetShape()[0] != 1)
1431 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
1432 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1441 const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.
GetShape()[3];
1442 const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.
GetShape()[1];
1443 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1446 bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
1447 bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
1449 if (!(validRefFormat || validAclFormat))
1452 "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] "
1453 "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is equal to Cout."
1454 "Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1463 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1468 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1471 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1474 ValidatePerAxisQuantization(inputTensorInfo,
1477 optionalBiasTensorInfo,
1480 std::vector<DataType> supportedTypes =
1490 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1491 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1496 const std::string descriptorName{
"PermuteQueueDescriptor"};
1498 ValidateNumInputs(workloadInfo, descriptorName, 1);
1499 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1509 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1511 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1514 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1515 "must match dst dimension " + to_string(mapping[i]) +
1516 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1520 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1525 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1527 ValidateNumInputs(workloadInfo, descriptorName, 1);
1528 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1536 std::vector<DataType> supportedTypes =
1546 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1547 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1552 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1554 ValidateNumInputs(workloadInfo, descriptorName, 1);
1555 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1563 std::vector<DataType> supportedTypes =
1573 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1574 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1579 const std::string descriptorName{
"ResizeQueueDescriptor"};
1581 ValidateNumInputs(workloadInfo, descriptorName, 1);
1582 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1590 std::vector<DataType> supportedTypes =
1601 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1602 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1605 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1606 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1607 if (inputBatchSize != outputBatchSize)
1610 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1611 descriptorName, inputBatchSize, outputBatchSize));
1617 if (inputChannelCount != outputChannelCount)
1620 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1621 descriptorName, inputChannelCount, outputChannelCount));
1627 const std::string descriptorName{
"ReverseV2QueueDescriptor"};
1630 const unsigned int maxDimensions = 4;
1632 ValidateNumInputs(workloadInfo, descriptorName, 2);
1633 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1640 if (inputTensorNumDimensions > maxDimensions)
1643 ": Input tensors with rank greater than " +
1644 std::to_string(maxDimensions) +
" are not supported.");
1648 if (axisTensorNumDimensions > maxDimensions)
1651 ": More than " + std::to_string(maxDimensions) +
" axes cannot be specified.");
1654 if (axisTensorNumDimensions > inputTensorNumDimensions)
1657 ": More axes specified than the number of axes on the input tensor.");
1660 std::vector<DataType> supportedTypes =
1672 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1674 std::vector<DataType> axisSupportedTypes =
1679 ValidateDataTypes(axisTensorInfo, axisSupportedTypes, descriptorName);
1681 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1682 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1687 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1689 ValidateNumInputs(workloadInfo, descriptorName, 1);
1690 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1698 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1708 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1710 ValidateNumInputs(workloadInfo, descriptorName, 1);
1711 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1721 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1724 std::vector<DataType> supportedTypes =
1731 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1732 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1737 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1739 ValidateNumInputs(workloadInfo, descriptorName, 1);
1740 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1750 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1753 std::vector<DataType> supportedTypes =
1763 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1764 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1769 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1771 ValidateNumInputs(workloadInfo, descriptorName, 1);
1772 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1777 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1779 std::vector<DataType> supportedTypes =
1786 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1787 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1792 const std::string descriptorName{
"ConstantQueueDescriptor"};
1794 ValidateNumInputs(workloadInfo, descriptorName, 0);
1795 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1806 std::vector<DataType> supportedTypes =
1818 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1823 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1825 ValidateNumInputs(workloadInfo, descriptorName, 1);
1826 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1831 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1834 std::vector<DataType> supportedTypes =
1846 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1847 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1852 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1854 ValidateNumInputs(workloadInfo, descriptorName, 1);
1855 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1863 "dimensions as Block Shape.");
1885 const unsigned int inputWidth = (inputTensorInfo.
GetNumDimensions() == 3) ? 1 :
1890 const unsigned int channelsIndex = channelsIndex_int < 0 ?
1891 static_cast<unsigned int>(channelsIndex_int) + inputTensorInfo.
GetNumDimensions()
1892 :
static_cast<unsigned int>(channelsIndex_int);
1894 const unsigned int numInputElements = inputTensorInfo.
GetShape()[0] *
1897 inputTensorInfo.
GetShape()[channelsIndex];
1902 to_string(numInputElements) +
" after padding but output tensor has " +
1911 unsigned int spatialDimension = firstSpatialDimension + i;
1912 auto inputSize = inputTensorInfo.
GetShape()[spatialDimension] +
1918 "divisible by Block Shape in dimension: " + to_string(spatialDimension) +
".");
1922 std::vector<DataType> supportedTypes =
1932 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1933 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1938 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1940 ValidateNumInputs(workloadInfo, descriptorName, 1);
1941 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1949 std::vector<DataType> supportedTypes =
1959 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1960 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1962 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1970 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1978 "by block size in all spatial dimensions");
1985 "must be divisible by the square of block size." );
1991 const std::string descriptorName{
"FloorQueueDescriptor"};
1993 ValidateNumInputs(workloadInfo, descriptorName, 1);
1994 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1999 std::vector<DataType> supportedTypes =
2007 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2008 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2009 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2010 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2017 const std::string descriptorName{
"LstmQueueDescriptor"};
2029 std::vector<DataType> supportedTypes =
2038 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
2047 "input_" + std::to_string(i));
2054 "LstmQueueDescriptor",
2056 "output_" + std::to_string(i));
2081 descriptorName +
" input_0");
2084 descriptorName +
" input_1");
2087 descriptorName +
" input_2");
2091 descriptorName +
" output_0");
2094 descriptorName +
" output_1");
2097 descriptorName +
" output_2");
2100 descriptorName +
" output_3");
2106 (n_cell * n_input),
"InputLayerNormWeights");
2111 (n_cell * n_input),
"InputToForgetWeights");
2115 (n_cell * n_input),
"InputToCellWeights");
2120 (n_cell * n_output),
"RecurrentToInputWeights");
2125 (n_cell * n_output),
"RecurrentToForgetWeights");
2129 (n_cell * n_output),
"RecurrentToCellWeights");
2137 if (!cifg_weights_all_or_none)
2140 "RecurrentToInputWeights must either both be present (regular LSTM) "
2141 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
2148 n_cell,
"CellToInputWeights");
2153 n_cell,
"CellToForgetWeights");
2158 n_cell,
"CellToOutputWeights");
2162 bool peephole_weights_all_or_none =
2167 if (!peephole_weights_all_or_none)
2185 "must be present.");
2188 n_cell,
"InputGateBias");
2194 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
2203 (n_cell * n_output),
"ProjectionWeights");
2220 if (!projecton_tensors_consistent)
2253 "disabled but InputLayerNormWeights are not present");
2256 1, n_cell,
"InputLayerNormWeights");
2265 "ForgetLayerNormWeights");
2269 "OutputLayerNormWeights");
2273 "CellLayerNormWeights");
2279 "normalisation weights are present.");
2285 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2287 ValidateNumInputs(workloadInfo, descriptorName, 1);
2288 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2303 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2308 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2310 ValidateNumInputs(workloadInfo, descriptorName, 1);
2311 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2326 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2331 const std::string descriptorName{
"DivisionQueueDescriptor"};
2333 ValidateNumInputs(workloadInfo, descriptorName, 2);
2334 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2340 std::vector<DataType> supportedTypes =
2351 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2352 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2353 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2355 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2365 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2367 ValidateNumInputs(workloadInfo, descriptorName, 2);
2368 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2374 std::vector<DataType> supportedTypes =
2385 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2386 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2387 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2389 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2399 const std::string descriptorName{
"MaximumQueueDescriptor"};
2401 ValidateNumInputs(workloadInfo, descriptorName, 2);
2402 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2408 std::vector<DataType> supportedTypes =
2419 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2420 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2421 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2423 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2433 const std::string descriptorName{
"MeanQueueDescriptor"};
2435 ValidateNumInputs(workloadInfo, descriptorName, 1);
2436 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2441 std::vector<DataType> supportedTypes =
2453 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2454 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2466 unsigned int outputDim =
2470 outputDim > 0 ? outputDim : 1,
2477 const std::string descriptorName{
"PadQueueDescriptor"};
2479 ValidateNumInputs(workloadInfo, descriptorName, 1);
2480 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2491 "as there are dimensions in the input tensor that is " +
2499 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2501 ValidateNumInputs(workloadInfo, descriptorName, 1);
2502 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2507 std::vector<DataType> supportedTypes =
2518 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2528 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2530 ValidateNumInputs(workloadInfo, descriptorName, 1);
2531 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2539 "dimensions as Block Shape.");
2562 unsigned int spatialDimension = firstSpatialDimension + i;
2565 if (cropSize > outputSize)
2568 "outputSize in dimension: " + to_string(spatialDimension) +
".");
2572 std::vector<DataType> supportedTypes =
2582 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2583 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2588 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2590 ValidateNumInputs(workloadInfo, descriptorName, 1);
2591 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2596 std::vector<DataType> supportedTypes =
2606 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2607 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2609 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2645 const std::string descriptorName{
"MinimumQueueDescriptor"};
2647 ValidateNumInputs(workloadInfo, descriptorName, 2);
2648 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2654 std::vector<DataType> supportedTypes =
2665 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2666 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2667 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2669 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2679 const std::string descriptorName{
"DebugQueueDescriptor"};
2681 ValidateNumInputs(workloadInfo, descriptorName, 1);
2682 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2687 const std::string descriptorName{
"EqualQueueDescriptor"};
2689 ValidateNumInputs(workloadInfo, descriptorName, 2);
2690 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2696 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2711 const std::string descriptorName{
"GreaterQueueDescriptor"};
2713 ValidateNumInputs(workloadInfo, descriptorName, 2);
2714 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2720 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2735 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2737 ValidateNumInputs(workloadInfo, descriptorName, 1);
2738 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2743 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2745 std::vector<DataType> supportedTypes =
2755 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2756 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2761 const std::string descriptorName{
"GatherNdQueueDescriptor"};
2763 ValidateNumInputs(workloadInfo, descriptorName, 2);
2764 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2775 std::vector<DataType> supportedTypes =
2786 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2788 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2796 const std::string descriptorName{
"GatherQueueDescriptor"};
2798 ValidateNumInputs(workloadInfo, descriptorName, 2);
2799 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2810 std::vector<DataType> supportedTypes =
2821 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2823 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2831 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2833 ValidateNumInputs(workloadInfo, descriptorName, 2);
2859 const std::vector<DataType> supportedInputTypes =
2869 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2870 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2871 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2879 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2880 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2881 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2882 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2887 "must be positive and less than or equal to 1.");
2893 "should be equal to number of classes + 1.");
2899 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2901 ValidateNumInputs(workloadInfo, descriptorName, 1);
2902 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2907 std::vector<DataType> inputSupportedTypes =
2915 ValidateDataTypes(inputTensorInfo, inputSupportedTypes, descriptorName);
2917 std::vector<DataType> outputSupportedTypes =
2924 ValidateDataTypes(outputTensorInfo, outputSupportedTypes, descriptorName);
2929 const std::string& descriptorName{
"MergeQueueDescriptor"};
2931 ValidateNumInputs(workloadInfo, descriptorName, 2);
2932 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2938 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2939 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2941 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2942 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2947 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2949 ValidateNumInputs(workloadInfo, descriptorName, 1);
2950 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2955 std::vector<DataType> supportedTypes =
2967 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2973 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2975 ValidateNumInputs(workloadInfo, descriptorName, 2);
2976 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2984 std::vector<DataType> supportedTypes =
2993 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2994 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2996 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2997 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2999 ValidateTensorShapesMatch(inputTensorInfo0,
3005 ValidateTensorShapesMatch(inputTensorInfo0,
3019 const std::string& descriptorName{
"PreluQueueDescriptor"};
3021 ValidateNumInputs(workloadInfo, descriptorName, 2);
3022 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3028 std::vector<DataType> supportedTypes
3038 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3039 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
3041 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
3043 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
3044 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
3046 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
3056 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
3058 ValidateNumInputs(workloadInfo, descriptorName, 1);
3059 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3067 ValidatePointer(
m_Weight, descriptorName,
"weight");
3072 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
3077 ValidatePointer(
m_Bias, descriptorName,
"bias");
3083 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
3086 ValidatePerAxisQuantization(inputTensorInfo,
3089 optionalBiasTensorInfo,
3092 std::vector<DataType> supportedTypes =
3102 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3103 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3108 const std::string descriptorName{
"TransposeQueueDescriptor"};
3110 ValidateNumInputs(workloadInfo, descriptorName, 1);
3111 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3121 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3123 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3126 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3127 "must match dst dimension " + to_string(i) +
3128 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3132 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3137 const std::string descriptorName{
"TransposeQueueDescriptor"};
3139 ValidateNumInputs(workloadInfo, descriptorName, 1);
3140 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3145 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3150 const std::string descriptorName{
"QLstmQueueDescriptor"};
3153 ValidateNumInputs(workloadInfo, descriptorName, 3);
3154 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3166 std::vector<DataType> inputOutputSupportedTypes =
3171 std::vector<DataType> cellStateSupportedTypes =
3176 std::vector<DataType> weightsSupportedTypes =
3181 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3186 std::vector<DataType> biasSupportedTypes =
3192 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3193 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3194 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3196 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3197 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3198 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3201 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3202 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3203 "outputStateIn",
"outputStateOut");
3204 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3207 const uint32_t numBatches = inputInfo.
GetShape()[0];
3208 const uint32_t inputSize = inputInfo.
GetShape()[1];
3209 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3210 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3237 " RecurrentToForgetWeights");
3248 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3250 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3251 "inputToForgetWeights",
"inputToCellWeights");
3252 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3253 "inputToForgetWeights",
"inputToOutputWeights");
3255 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3256 "inputToForgetWeights",
"recurrentToForgeteights");
3257 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3258 "inputToForgetWeights",
"recurrentToCellWeights");
3259 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3260 "inputToForgetWeights",
"recurrentToOutputWeights");
3267 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3276 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3278 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3279 "forgetGateBias",
"cellBias");
3280 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3281 "forgetGateBias",
"outputGateBias");
3289 if (!allCifgParamsPresentOrNot)
3292 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present "
3293 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be "
3294 "set appropriately.");
3305 " RecurrentToInputWeights");
3311 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3312 "inputToForgetWeights",
"inputToInputWeights");
3313 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3314 "inputToForgetWeights",
"recurrentToInputWeights");
3315 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3316 "forgetGateBias",
"inputGateBias");
3320 bool allPeepholeWeightsPresentOrNot =
3326 if (!allPeepholeWeightsPresentOrNot)
3329 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole "
3330 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present "
3331 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set "
3339 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3343 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3344 "cellToForgetWeight",
"cellToOutputWeights");
3350 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3351 "cellToForgetWeights",
"cellToInputWeights");
3356 bool allLayerNormWeightsPresentOrNot =
3362 if (!allLayerNormWeightsPresentOrNot)
3365 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights "
3366 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not "
3367 "be present at all (Layer Norm disabled). InputLayerNormWeights should "
3368 "only be present when Layer Norm is enabled and CIFG is disabled. "
3369 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3376 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3380 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3381 "forgetLayerNormWeights",
"cellLayerNormWeights");
3385 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3386 "forgetLayerNormWeights",
"outputLayerNormWeights");
3392 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3393 "forgetLayerNormWeights",
"inputLayerNormWeights");
3398 bool correctProjectionTensorsPresent =
3403 if (!correctProjectionTensorsPresent)
3406 ": If projection is enabled, ProjectionWeights should be present and "
3407 "ProjectionBias is optional. If projection is disabled, neither "
3408 "ProjectionWeights nor ProjectionBias should be present.");
3415 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3421 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3428 ": If projection is disabled, output quantization info (scale, offset) "
3429 "should match HiddenStateScale and HiddenStateZeroPoint.");
3436 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3439 ValidateNumInputs(workloadInfo, descriptorName, 3);
3440 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3450 std::vector<DataType> inputOutputSupportedTypes =
3455 std::vector<DataType> cellStateSupportedTypes =
3460 std::vector<DataType> weightsSupportedTypes =
3465 std::vector<DataType> biasSupportedTypes =
3471 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3472 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3473 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3475 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3476 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3479 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3480 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3481 "outputStateIn",
"outputStateOut");
3482 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3485 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3486 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3487 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3490 const uint32_t numBatches = inputInfo.
GetShape()[0];
3491 const uint32_t inputSize = inputInfo.
GetShape()[1];
3492 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3525 " RecurrentToForgetWeights");
3536 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3538 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3539 "inputToInputWeights",
"inputToForgetWeights");
3540 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3541 "inputToInputWeights",
"inputToCellWeights");
3542 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3543 "inputToInputWeights",
"inputToOutputWeights");
3545 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3546 "inputToInputWeights",
"recurrentToInputWeights");
3547 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3548 "inputToInputWeights",
"recurrentToForgeteights");
3549 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3550 "inputToInputWeights",
"recurrentToCellWeights");
3551 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3552 "inputToInputWeights",
"recurrentToOutputWeights");
3555 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3556 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3557 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3558 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3559 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3560 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3562 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3563 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3564 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3565 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3566 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3567 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3568 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3569 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3580 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3589 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3591 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3592 "inputGateBias",
"forgetGateBias");
3593 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3594 "inputGateBias",
"cellBias");
3595 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3596 "inputGateBias",
"outputGateBias");
3599 ValidateBiasTensorQuantization(inputGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3600 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3601 ValidateBiasTensorQuantization(cellBiasInfo, inputToInputWeightsInfo, descriptorName);
3602 ValidateBiasTensorQuantization(outputGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3607 const std::string descriptorName{
"AbsQueueDescriptor"};
3609 ValidateNumInputs(workloadInfo, descriptorName, 1);
3610 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3615 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3617 std::vector<DataType> supportedTypes =
3628 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3629 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3634 const std::string descriptorName{
"SliceQueueDescriptor"};
3636 ValidateNumInputs(workloadInfo, descriptorName, 1);
3637 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3642 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3656 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3661 ": Length of size descriptor must equal rank " + std::to_string(rank));
3666 for (
unsigned int i = 0u; i < rank; ++i)
3677 for(
unsigned int i = 0u; i < rank; ++i)
3682 std::to_string(i) +
" exceeds input size.");
3689 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3691 ValidateNumInputs(workloadInfo, descriptorName, 1);
3692 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3700 std::vector<DataType> supportedTypes =
3710 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3711 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3713 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3721 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3729 "must be divisible by block size.");
3736 "must be divisible by the square of block size." );
3742 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3744 ValidateNumInputs(workloadInfo, descriptorName, 2);
3745 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3751 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3766 const std::string descriptorName{
"ElementwiseBinaryQueueDescriptor"};
3768 ValidateNumInputs(workloadInfo, descriptorName, 2);
3769 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3775 std::vector<DataType> supportedTypes =
3786 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
3787 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
3789 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input",
"output");
3790 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input",
"output");
3795 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3797 ValidateNumInputs(workloadInfo, descriptorName, 1);
3798 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3803 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3805 std::vector<DataType> supportedTypes =
3816 std::vector<DataType> logicalSupportedTypes =
3823 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3827 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3831 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3836 const std::string descriptorName{
"RankQueueDescriptor"};
3838 ValidateNumInputs(workloadInfo, descriptorName, 1);
3839 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3845 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3847 std::vector<DataType> supportedTypes =
3859 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3865 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3867 ValidateNumInputs(workloadInfo, descriptorName, 2);
3868 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3874 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3899 const std::string descriptorName{
"ReduceQueueDescriptor"};
3901 ValidateNumInputs(workloadInfo, descriptorName, 1);
3902 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3907 std::vector<DataType> supportedTypes =
3918 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3919 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3926 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3938 std::vector<DataType> supportedTypes =
3945 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3959 unsigned int batchIndx = 0;
3960 unsigned int inputIndx = 1;
3961 uint32_t timeStep = 1;
3962 unsigned int timeIndx = 1;
3982 descriptorName +
" input_0");
3985 descriptorName +
" input_1");
3988 descriptorName +
" input_2");
3992 descriptorName +
" output_0");
3998 (n_cell * n_input),
"InputLayerNormWeights");
4003 (n_cell * n_input),
"InputToForgetWeights");
4007 (n_cell * n_input),
"InputToCellWeights");
4012 (n_cell * n_output),
"RecurrentToInputWeights");
4017 (n_cell * n_output),
"RecurrentToForgetWeights");
4021 (n_cell * n_output),
"RecurrentToCellWeights");
4029 if (!cifg_weights_all_or_none)
4032 "RecurrentToInputWeights must either both be present (regular LSTM) "
4033 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
4040 n_cell,
"CellToInputWeights");
4045 n_cell,
"CellToForgetWeights");
4050 n_cell,
"CellToOutputWeights");
4054 bool peephole_weights_all_or_none =
4059 if (!peephole_weights_all_or_none)
4077 "must be present.");
4080 n_cell,
"InputGateBias");
4086 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
4095 (n_cell * n_output),
"ProjectionWeights");
4112 if (!projecton_tensors_consistent)
4145 "disabled but InputLayerNormWeights are not present");
4148 1, n_cell,
"InputLayerNormWeights");
4157 "ForgetLayerNormWeights");
4161 "OutputLayerNormWeights");
4165 "CellLayerNormWeights");
4171 "normalisation weights are present.");
4177 const std::string descriptorName{
"BatchMatMulDescriptor"};
4179 ValidateNumInputs(workloadInfo, descriptorName, 2);
4180 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4191 std::vector<DataType> supportedTypes =
4201 ValidateDataTypes(inputXInfoBeforeParams, supportedTypes, descriptorName);
4202 ValidateDataTypes(inputYInfoBeforeParams, supportedTypes, descriptorName);
4203 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
4205 if ((inputXInfoBeforeParams.GetNumDimensions() < 2) ||
4206 (inputYInfoBeforeParams.GetNumDimensions() < 2))
4218 ": Invalid descriptor parameters - Transpose and Adjoint "
4219 "cannot both be true for a given input tensor.");
4226 inputXInfoBeforeParams.GetShape()));
4231 inputXInfoBeforeParams.GetShape());
4232 if(inputXInfoBeforeParams.GetShape()[axesToMul.first] !=
4233 inputXInfoBeforeParams.GetShape()[axesToMul.second])
4236 ": Adjoint is set to true for input tensor X, but the axes to be adjointed are not square." );
4239 inputXInfoAfterParams = inputXInfoBeforeParams;
4243 inputXInfoAfterParams = inputXInfoBeforeParams;
4251 inputYInfoBeforeParams.GetShape()));
4256 inputYInfoBeforeParams.GetShape());
4257 if(inputYInfoBeforeParams.GetShape()[axesToMul.first] !=
4258 inputYInfoBeforeParams.GetShape()[axesToMul.second])
4261 ": Adjoint is set to true for input tensor Y, but the axes to be adjointed are not square." );
4264 inputYInfoAfterParams = inputYInfoBeforeParams;
4268 inputYInfoAfterParams = inputYInfoBeforeParams;
4278 ": Input tensor X does not have the correct "
4279 "number of dimensions for the Data Layout that it has been assigned.");
4295 ": Input tensor Y does not have the correct "
4296 "number of dimensions for the Data Layout that it has been assigned.");
4308 inputXInfoBeforeParams.GetShape());
4310 if(inputXInfoAfterParams.
GetShape()[axesXToMul.second]
4311 != inputYInfoAfterParams.
GetShape()[axesYToMul.first])
4314 ": The final axis of input tensor X must be the same size as "
4315 "the second last axis of input tensor Y.");
4328 ": Invalid input tensor data layout combination.");
4336 ": Invalid input tensor data layout combination.");
4342 unsigned int outputTensorDimSize = std::max(inputXInfoAfterParams.
GetNumDimensions(),
4344 if(outputTensorDimSize-2 > 0)
4353 auto doAxisExtension = [&](std::vector<unsigned int> axisIndices,
TensorInfo& ti)
4355 auto sizeDiff = (outputTensorDimSize-2) - axisIndices.size();
4357 for(
unsigned int i = 0; i < sizeDiff; i++)
4359 axisIndices.insert(axisIndices.begin(), 1);
4362 for(
unsigned int i = 0; i < ti.GetNumDimensions(); i++)
4364 ti.GetShape()[i] = inputXInfoAfterParams.
GetShape()[i];
4373 doAxisExtension(axesXNotMul, tiXNotMul);
4374 doAxisExtension(axesYNotMul, tiYNotMul);
4382 ValidateBroadcastTensorShapesMatch(tiXNotMul,
4393 const std::string& descriptorName{
"TileQueueDescriptor"};
4395 ValidateNumInputs(workloadInfo, descriptorName, 1);
4396 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4401 std::vector<DataType> supportedTypes =
4416 ": Multiples length is not same as the number of dimensions in Input.");
4419 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
4420 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
4425 const std::string& descriptorName{
"BroadcastToQueueDescriptor"};
4427 ValidateNumInputs(workloadInfo, descriptorName, 1);
4428 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4433 std::vector<DataType> supportedTypes =
4445 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
4446 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
4451 const std::string& descriptorName{
"ScatterQueueDescriptor"};
4453 ValidateNumInputs(workloadInfo, descriptorName, 3);
4454 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4461 std::vector<DataType> supportedTypes =
4472 std::vector<DataType> indicesSupportedTypes =
4479 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
4483 ValidateDataTypes(inputTensorInfo0, indicesSupportedTypes, descriptorName);
4486 ValidateDataTypes(inputTensorInfo1, indicesSupportedTypes, descriptorName);
4487 ValidateDataTypes(inputTensorInfo2, supportedTypes, descriptorName);
4488 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);