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;
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). " +
110 void ValidateTensorNumElements(
const TensorInfo& tensor,
111 std::string
const& descName,
112 unsigned int numElements,
113 std::string
const& tensorName)
119 tensorName +
" tensor.");
125 const std::string& descName, std::string
const& tensorName)
134 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
139 ": Expected data type which supports per-axis quantization scheme but got " +
145 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
147 const std::string& descName,
148 std::string
const& firstName,
149 std::string
const& secondName)
161 if (firstDataType != secondDataType)
164 " must be of the same quantized type, " +
172 " must have the same quantization space, " +
181 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
183 const std::string& descName)
197 if (weightScales.size() != biasScales.size())
199 std::stringstream msg;
200 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, "
201 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
202 <<
", biases=" << biasScales.size();
209 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
210 unsigned int numExpected,
211 const std::string& descName,
212 const std::string& varName)
214 if (vec.empty() && numExpected > 0)
219 for (
unsigned int i = 0; i < numExpected; ++i)
229 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
232 std::string
const& descName,
233 std::string
const& firstName,
234 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())
278 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
280 std::string
const& descName,
281 std::string
const& firstName,
282 std::string
const& secondName)
287 " must have identical data types.");
292 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
294 std::string
const& descName,
295 std::string
const& firstName,
296 std::string
const& secondName)
301 " must have the same number of elements.");
305 void ValidateWeightDataType(
const TensorInfo& inputInfo,
307 const std::string& descName)
312 const std::vector<DataType> validTypes =
319 ValidateDataTypes(weightInfo, validTypes, descName);
323 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
327 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
328 const std::string& descName,
329 const std::string& tensorName)
335 "not set on tensor {1}.", descName, tensorName));
339 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
340 const std::string& descName,
341 const std::string& tensorName)
344 if (quantizationOffset != 0)
347 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
348 descName, tensorName, quantizationOffset));
352 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
356 const std::string& descName)
363 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
365 if (!canHavePerAxisQuantization)
368 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support "
369 "per-axis quantization.", descName,
"weight"));
373 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
374 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
375 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
383 "{}: Per-axis quantization parameters not set on bias tensor, "
384 "despite being set on weight tensor.", descName));
387 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
388 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
389 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
398 std::string
const& descName,
399 unsigned int numDimensions,
400 std::string
const& tensorName)
const
407 unsigned int squeezedDims = 0;
416 if (tensor.
GetNumDimensions() < numDimensions || squeezedDims > numDimensions)
420 tensorName +
" tensor.");
429 tensorName +
" tensor.");
436 unsigned int numDimension,
437 unsigned int numElements,
438 std::string
const& tensorName)
const
440 const std::string functionName{
"ValidateTensorNumDimNumElem"};
442 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
447 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const
449 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
450 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
456 const std::string descriptorName{
"MapQueueDescriptor"};
458 ValidateNumInputs(workloadInfo, descriptorName, 1);
459 ValidateNumOutputs(workloadInfo, descriptorName, 0);
461 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
466 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
474 const std::string descriptorName{
"UnmapQueueDescriptor"};
476 ValidateNumInputs(workloadInfo, descriptorName, 1);
477 ValidateNumOutputs(workloadInfo, descriptorName, 0);
479 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
484 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
492 const std::string descriptorName{
"MemCopyQueueDescriptor"};
494 ValidateNumInputs(workloadInfo, descriptorName, 1);
495 ValidateNumOutputs(workloadInfo, descriptorName , 1);
500 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
501 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
506 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
510 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
515 "{0}: Invalid NULL input {1}.", descriptorName, i));
528 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
529 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
541 "Number of input infos ({0}) does not match the number of output infos ({1})",
551 "Number of elements for tensor input and output {} does not match", i ));
563 "Number of inputs ({0}) does not match the number of outputs ({1})",
567 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
584 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
605 const std::string descriptorName{
"ActivationQueueDescriptor"};
607 ValidateNumInputs(workloadInfo, descriptorName, 1);
608 ValidateNumOutputs(workloadInfo, descriptorName, 1);
613 std::vector<DataType> supportedTypes =
623 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
624 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
625 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
630 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
632 ValidateNumInputs(workloadInfo, descriptorName, 1);
633 ValidateNumOutputs(workloadInfo, descriptorName, 1);
644 std::vector<DataType> supportedInputTypes =
656 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
658 auto inputShape = inputTensorInfo.
GetShape();
659 auto outputShape = outputTensorInfo.
GetShape();
664 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
667 if (inputShape.GetNumDimensions() == 1)
669 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
676 for (
unsigned int i = 0; i < unsignedAxis; ++i)
678 if (outputShape[i] != inputShape[i])
684 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
686 if (outputShape[i - 1] != inputShape[i])
696 const std::string descriptorName{
"CastQueueDescriptor"};
698 ValidateNumInputs(workloadInfo, descriptorName, 1);
699 ValidateNumOutputs(workloadInfo, descriptorName, 1);
704 std::vector<DataType> supportedTypes =
717 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
718 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
723 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
725 ValidateNumInputs(workloadInfo, descriptorName, 1);
726 ValidateNumOutputs(workloadInfo, descriptorName, 1);
731 std::vector<DataType> supportedTypes =
741 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
742 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
743 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
748 const std::string descriptorName{
"SplitterQueueDescriptor"};
750 ValidateNumInputs(workloadInfo, descriptorName, 1);
753 std::vector<DataType> supportedTypes =
769 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
771 const std::string outputName =
"output_" + std::to_string(i);
772 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
783 descriptorName +
": Number of split windows "
784 "has to match number of workloadInfo.m_OutputTensorInfos. "
785 "Number of windows: " +
787 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
799 "have the same dimensionality as the input tensor. "
800 "Window origin (index: " +
801 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
802 " dimensions, the input "
804 to_string(inputDims) +
" dimensions.");
806 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
812 "be smaller or equal than the size of the input in that coord.");
820 const std::string descriptorName{
"ConcatQueueDescriptor"};
822 ValidateNumOutputs(workloadInfo, descriptorName, 1);
855 descriptorName +
": Number of split windows "
856 "has to match number of workloadInfo.m_InputTensorInfos. "
857 "Number of windows: " +
859 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
868 if (e.
m_Origin.size() != outputDims)
871 "have the same dimensionality as the output tensor. "
872 "Window origin (index: " +
873 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
874 " dimensions, the output "
876 to_string(outputDims) +
" dimensions.");
879 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
885 "be smaller or equal than the size of the output in that coord.");
891 std::vector<DataType> supportedTypes =
907 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
909 const std::string inputName =
"input_" + std::to_string(i);
910 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
916 const std::string descriptorName{
"StackQueueDescriptor"};
918 ValidateNumOutputs(workloadInfo, descriptorName, 1);
945 "than the number of input dimensions.");
952 if (outputShape[i] != inputShape[i])
955 "match shape inferred from input tensor.");
962 "match shape inferred from input tensor.");
967 if (outputShape[i] != inputShape[i-1])
970 "match shape inferred from input tensor.");
980 std::vector<DataType> supportedTypes =
992 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1000 "input_" + std::to_string(i));
1012 const std::string descriptorName{
"FillQueueDescriptor"};
1014 ValidateNumInputs(workloadInfo, descriptorName, 1);
1015 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1022 std::vector<DataType> supportedTypes =
1030 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1035 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1037 uint32_t numInputs = 2;
1043 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1044 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1063 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1069 std::vector<DataType> supportedTypes =
1079 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1087 "for BFloat16 input.");
1092 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1098 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1100 ValidateNumInputs(workloadInfo, descriptorName, 1);
1101 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1107 std::vector<DataType> supportedTypes =
1117 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1119 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1121 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1126 const std::string descriptorName{
"AdditionQueueDescriptor"};
1128 ValidateNumInputs(workloadInfo, descriptorName, 2);
1129 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1135 std::vector<DataType> supportedTypes =
1146 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1147 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1148 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1150 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1151 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1153 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1163 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1165 ValidateNumInputs(workloadInfo, descriptorName, 2);
1166 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1172 std::vector<DataType> supportedTypes =
1183 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1184 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1185 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1187 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1188 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1190 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1200 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1202 ValidateNumInputs(workloadInfo, descriptorName, 1);
1203 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1208 std::vector<DataType> supportedTypes =
1218 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1219 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1221 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1222 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1224 ValidatePointer(
m_Mean, descriptorName,
"mean");
1225 ValidatePointer(
m_Variance, descriptorName,
"variance");
1226 ValidatePointer(
m_Beta, descriptorName,
"beta");
1227 ValidatePointer(
m_Gamma, descriptorName,
"gamma");
1239 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1240 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1241 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1246 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1248 uint32_t numInputs = 2;
1254 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1255 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1267 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1272 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1276 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1282 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1283 "cannot be either negative or 0.",
1287 ValidatePerAxisQuantization(inputTensorInfo,
1290 optionalBiasTensorInfo,
1293 std::vector<DataType> supportedTypes =
1304 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1312 "for BFloat16 input.");
1317 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1323 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1325 uint32_t numInputs = 2;
1330 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1331 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1342 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1347 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1351 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1357 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})"
1358 "cannot be either negative or 0.",
1362 ValidatePerAxisQuantization(inputTensorInfo,
1365 optionalBiasTensorInfo,
1368 std::vector<DataType> supportedTypes =
1379 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1380 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1385 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1387 uint32_t numInputs = 2;
1393 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1394 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1408 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) "
1409 "cannot be smaller than 1.",
1416 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1417 "cannot be either negative or 0.",
1421 if (weightTensorInfo.
GetShape()[0] != 1)
1424 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
1425 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1434 const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.
GetShape()[3];
1435 const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.
GetShape()[1];
1436 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1439 bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
1440 bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
1442 if (!(validRefFormat || validAclFormat))
1445 "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] "
1446 "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is equal to Cout."
1447 "Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1456 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1461 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1464 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
1467 ValidatePerAxisQuantization(inputTensorInfo,
1470 optionalBiasTensorInfo,
1473 std::vector<DataType> supportedTypes =
1483 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1484 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1489 const std::string descriptorName{
"PermuteQueueDescriptor"};
1491 ValidateNumInputs(workloadInfo, descriptorName, 1);
1492 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1502 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1504 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1507 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1508 "must match dst dimension " + to_string(mapping[i]) +
1509 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1513 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1518 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1520 ValidateNumInputs(workloadInfo, descriptorName, 1);
1521 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1529 std::vector<DataType> supportedTypes =
1539 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1540 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1545 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1547 ValidateNumInputs(workloadInfo, descriptorName, 1);
1548 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1556 std::vector<DataType> supportedTypes =
1566 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1567 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1572 const std::string descriptorName{
"ResizeQueueDescriptor"};
1574 ValidateNumInputs(workloadInfo, descriptorName, 1);
1575 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1583 std::vector<DataType> supportedTypes =
1593 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1594 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1597 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1598 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1599 if (inputBatchSize != outputBatchSize)
1602 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1603 descriptorName, inputBatchSize, outputBatchSize));
1609 if (inputChannelCount != outputChannelCount)
1612 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1613 descriptorName, inputChannelCount, outputChannelCount));
1619 const std::string descriptorName{
"ReverseV2QueueDescriptor"};
1622 const unsigned int maxDimensions = 4;
1624 ValidateNumInputs(workloadInfo, descriptorName, 2);
1625 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1632 if (inputTensorNumDimensions > maxDimensions)
1635 ": Input tensors with rank greater than " +
1636 std::to_string(maxDimensions) +
" are not supported.");
1640 if (axisTensorNumDimensions > maxDimensions)
1643 ": More than " + std::to_string(maxDimensions) +
" axes cannot be specified.");
1646 if (axisTensorNumDimensions > inputTensorNumDimensions)
1649 ": More axes specified than the number of axes on the input tensor.");
1652 std::vector<DataType> supportedTypes =
1664 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1666 std::vector<DataType> axisSupportedTypes =
1671 ValidateDataTypes(axisTensorInfo, axisSupportedTypes, descriptorName);
1673 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1674 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1679 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1681 ValidateNumInputs(workloadInfo, descriptorName, 1);
1682 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1690 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1700 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1702 ValidateNumInputs(workloadInfo, descriptorName, 1);
1703 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1713 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1716 std::vector<DataType> supportedTypes =
1723 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1724 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1729 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1731 ValidateNumInputs(workloadInfo, descriptorName, 1);
1732 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1742 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1745 std::vector<DataType> supportedTypes =
1755 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1756 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1761 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1763 ValidateNumInputs(workloadInfo, descriptorName, 1);
1764 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1769 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1771 std::vector<DataType> supportedTypes =
1778 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1779 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1784 const std::string descriptorName{
"ConstantQueueDescriptor"};
1786 ValidateNumInputs(workloadInfo, descriptorName, 0);
1787 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1798 std::vector<DataType> supportedTypes =
1810 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1815 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1817 ValidateNumInputs(workloadInfo, descriptorName, 1);
1818 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1823 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1826 std::vector<DataType> supportedTypes =
1838 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1839 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1844 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1846 ValidateNumInputs(workloadInfo, descriptorName, 1);
1847 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1855 "dimensions as Block Shape.");
1877 const unsigned int inputWidth = (inputTensorInfo.
GetNumDimensions() == 3) ? 1 :
1882 const unsigned int channelsIndex = channelsIndex_int < 0 ?
1883 static_cast<unsigned int>(channelsIndex_int) + inputTensorInfo.
GetNumDimensions()
1884 :
static_cast<unsigned int>(channelsIndex_int);
1886 const unsigned int numInputElements = inputTensorInfo.
GetShape()[0] *
1889 inputTensorInfo.
GetShape()[channelsIndex];
1894 to_string(numInputElements) +
" after padding but output tensor has " +
1903 unsigned int spatialDimension = firstSpatialDimension + i;
1904 auto inputSize = inputTensorInfo.
GetShape()[spatialDimension] +
1910 "divisible by Block Shape in dimension: " + to_string(spatialDimension) +
".");
1914 std::vector<DataType> supportedTypes =
1924 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1925 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1930 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1932 ValidateNumInputs(workloadInfo, descriptorName, 1);
1933 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1941 std::vector<DataType> supportedTypes =
1951 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1952 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1954 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1962 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1970 "by block size in all spatial dimensions");
1977 "must be divisible by the square of block size." );
1983 const std::string descriptorName{
"FloorQueueDescriptor"};
1985 ValidateNumInputs(workloadInfo, descriptorName, 1);
1986 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1991 std::vector<DataType> supportedTypes =
1999 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2000 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2001 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2002 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2009 const std::string descriptorName{
"LstmQueueDescriptor"};
2021 std::vector<DataType> supportedTypes =
2030 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
2039 "input_" + std::to_string(i));
2046 "LstmQueueDescriptor",
2048 "output_" + std::to_string(i));
2073 descriptorName +
" input_0");
2076 descriptorName +
" input_1");
2079 descriptorName +
" input_2");
2083 descriptorName +
" output_0");
2086 descriptorName +
" output_1");
2089 descriptorName +
" output_2");
2092 descriptorName +
" output_3");
2098 (n_cell * n_input),
"InputLayerNormWeights");
2103 (n_cell * n_input),
"InputToForgetWeights");
2107 (n_cell * n_input),
"InputToCellWeights");
2112 (n_cell * n_output),
"RecurrentToInputWeights");
2117 (n_cell * n_output),
"RecurrentToForgetWeights");
2121 (n_cell * n_output),
"RecurrentToCellWeights");
2129 if (!cifg_weights_all_or_none)
2132 "RecurrentToInputWeights must either both be present (regular LSTM) "
2133 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
2140 n_cell,
"CellToInputWeights");
2145 n_cell,
"CellToForgetWeights");
2150 n_cell,
"CellToOutputWeights");
2154 bool peephole_weights_all_or_none =
2159 if (!peephole_weights_all_or_none)
2177 "must be present.");
2180 n_cell,
"InputGateBias");
2186 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
2195 (n_cell * n_output),
"ProjectionWeights");
2212 if (!projecton_tensors_consistent)
2245 "disabled but InputLayerNormWeights are not present");
2248 1, n_cell,
"InputLayerNormWeights");
2257 "ForgetLayerNormWeights");
2261 "OutputLayerNormWeights");
2265 "CellLayerNormWeights");
2271 "normalisation weights are present.");
2277 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2279 ValidateNumInputs(workloadInfo, descriptorName, 1);
2280 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2295 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2300 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2302 ValidateNumInputs(workloadInfo, descriptorName, 1);
2303 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2318 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2323 const std::string descriptorName{
"DivisionQueueDescriptor"};
2325 ValidateNumInputs(workloadInfo, descriptorName, 2);
2326 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2332 std::vector<DataType> supportedTypes =
2343 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2344 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2345 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2347 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2357 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2359 ValidateNumInputs(workloadInfo, descriptorName, 2);
2360 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2366 std::vector<DataType> supportedTypes =
2377 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2378 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2379 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2381 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2391 const std::string descriptorName{
"MaximumQueueDescriptor"};
2393 ValidateNumInputs(workloadInfo, descriptorName, 2);
2394 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2400 std::vector<DataType> supportedTypes =
2411 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2412 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2413 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2415 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2425 const std::string descriptorName{
"MeanQueueDescriptor"};
2427 ValidateNumInputs(workloadInfo, descriptorName, 1);
2428 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2433 std::vector<DataType> supportedTypes =
2445 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2446 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2458 unsigned int outputDim =
2462 outputDim > 0 ? outputDim : 1,
2469 const std::string descriptorName{
"PadQueueDescriptor"};
2471 ValidateNumInputs(workloadInfo, descriptorName, 1);
2472 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2483 "as there are dimensions in the input tensor that is " +
2491 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2493 ValidateNumInputs(workloadInfo, descriptorName, 1);
2494 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2499 std::vector<DataType> supportedTypes =
2510 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2520 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2522 ValidateNumInputs(workloadInfo, descriptorName, 1);
2523 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2531 "dimensions as Block Shape.");
2554 unsigned int spatialDimension = firstSpatialDimension + i;
2557 if (cropSize > outputSize)
2560 "outputSize in dimension: " + to_string(spatialDimension) +
".");
2564 std::vector<DataType> supportedTypes =
2574 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2575 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2580 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2582 ValidateNumInputs(workloadInfo, descriptorName, 1);
2583 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2588 std::vector<DataType> supportedTypes =
2598 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2599 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2601 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2637 const std::string descriptorName{
"MinimumQueueDescriptor"};
2639 ValidateNumInputs(workloadInfo, descriptorName, 2);
2640 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2646 std::vector<DataType> supportedTypes =
2657 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2658 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2659 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2661 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2671 const std::string descriptorName{
"DebugQueueDescriptor"};
2673 ValidateNumInputs(workloadInfo, descriptorName, 1);
2674 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2679 const std::string descriptorName{
"EqualQueueDescriptor"};
2681 ValidateNumInputs(workloadInfo, descriptorName, 2);
2682 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2688 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2703 const std::string descriptorName{
"GreaterQueueDescriptor"};
2705 ValidateNumInputs(workloadInfo, descriptorName, 2);
2706 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2712 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2727 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2729 ValidateNumInputs(workloadInfo, descriptorName, 1);
2730 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2735 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2737 std::vector<DataType> supportedTypes =
2747 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2748 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2753 const std::string descriptorName{
"GatherNdQueueDescriptor"};
2755 ValidateNumInputs(workloadInfo, descriptorName, 2);
2756 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2767 std::vector<DataType> supportedTypes =
2778 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2780 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2788 const std::string descriptorName{
"GatherQueueDescriptor"};
2790 ValidateNumInputs(workloadInfo, descriptorName, 2);
2791 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2802 std::vector<DataType> supportedTypes =
2813 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2815 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2823 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2825 ValidateNumInputs(workloadInfo, descriptorName, 2);
2851 const std::vector<DataType> supportedInputTypes =
2861 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2862 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2863 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2871 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2872 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2873 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2874 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2879 "must be positive and less than or equal to 1.");
2885 "should be equal to number of classes + 1.");
2891 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2893 ValidateNumInputs(workloadInfo, descriptorName, 1);
2894 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2899 std::vector<DataType> inputSupportedTypes =
2907 ValidateDataTypes(inputTensorInfo, inputSupportedTypes, descriptorName);
2909 std::vector<DataType> outputSupportedTypes =
2916 ValidateDataTypes(outputTensorInfo, outputSupportedTypes, descriptorName);
2921 const std::string& descriptorName{
"MergeQueueDescriptor"};
2923 ValidateNumInputs(workloadInfo, descriptorName, 2);
2924 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2930 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2931 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2933 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2934 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2939 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2941 ValidateNumInputs(workloadInfo, descriptorName, 1);
2942 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2947 std::vector<DataType> supportedTypes =
2959 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2965 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2967 ValidateNumInputs(workloadInfo, descriptorName, 2);
2968 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2976 std::vector<DataType> supportedTypes =
2985 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2986 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2988 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2989 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2991 ValidateTensorShapesMatch(inputTensorInfo0,
2997 ValidateTensorShapesMatch(inputTensorInfo0,
3011 const std::string& descriptorName{
"PreluQueueDescriptor"};
3013 ValidateNumInputs(workloadInfo, descriptorName, 2);
3014 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3020 std::vector<DataType> supportedTypes
3030 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3031 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
3033 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
3035 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
3036 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
3038 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
3048 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
3050 ValidateNumInputs(workloadInfo, descriptorName, 1);
3051 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3059 ValidatePointer(
m_Weight, descriptorName,
"weight");
3064 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
3069 ValidatePointer(
m_Bias, descriptorName,
"bias");
3075 ValidateBiasTensorQuantization(biasTensorInfo, weightTensorInfo, descriptorName);
3078 ValidatePerAxisQuantization(inputTensorInfo,
3081 optionalBiasTensorInfo,
3084 std::vector<DataType> supportedTypes =
3094 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3095 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3100 const std::string descriptorName{
"TransposeQueueDescriptor"};
3102 ValidateNumInputs(workloadInfo, descriptorName, 1);
3103 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3113 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3115 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3118 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3119 "must match dst dimension " + to_string(i) +
3120 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3124 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3129 const std::string descriptorName{
"TransposeQueueDescriptor"};
3131 ValidateNumInputs(workloadInfo, descriptorName, 1);
3132 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3137 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3142 const std::string descriptorName{
"QLstmQueueDescriptor"};
3145 ValidateNumInputs(workloadInfo, descriptorName, 3);
3146 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3158 std::vector<DataType> inputOutputSupportedTypes =
3163 std::vector<DataType> cellStateSupportedTypes =
3168 std::vector<DataType> weightsSupportedTypes =
3173 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3178 std::vector<DataType> biasSupportedTypes =
3184 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3185 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3186 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3188 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3189 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3190 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3193 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3194 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3195 "outputStateIn",
"outputStateOut");
3196 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3199 const uint32_t numBatches = inputInfo.
GetShape()[0];
3200 const uint32_t inputSize = inputInfo.
GetShape()[1];
3201 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3202 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3229 " RecurrentToForgetWeights");
3240 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3242 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3243 "inputToForgetWeights",
"inputToCellWeights");
3244 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3245 "inputToForgetWeights",
"inputToOutputWeights");
3247 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3248 "inputToForgetWeights",
"recurrentToForgeteights");
3249 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3250 "inputToForgetWeights",
"recurrentToCellWeights");
3251 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3252 "inputToForgetWeights",
"recurrentToOutputWeights");
3259 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3268 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3270 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3271 "forgetGateBias",
"cellBias");
3272 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3273 "forgetGateBias",
"outputGateBias");
3281 if (!allCifgParamsPresentOrNot)
3284 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present "
3285 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be "
3286 "set appropriately.");
3297 " RecurrentToInputWeights");
3303 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3304 "inputToForgetWeights",
"inputToInputWeights");
3305 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3306 "inputToForgetWeights",
"recurrentToInputWeights");
3307 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3308 "forgetGateBias",
"inputGateBias");
3312 bool allPeepholeWeightsPresentOrNot =
3318 if (!allPeepholeWeightsPresentOrNot)
3321 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole "
3322 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present "
3323 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set "
3331 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3335 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3336 "cellToForgetWeight",
"cellToOutputWeights");
3342 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3343 "cellToForgetWeights",
"cellToInputWeights");
3348 bool allLayerNormWeightsPresentOrNot =
3354 if (!allLayerNormWeightsPresentOrNot)
3357 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights "
3358 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not "
3359 "be present at all (Layer Norm disabled). InputLayerNormWeights should "
3360 "only be present when Layer Norm is enabled and CIFG is disabled. "
3361 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3368 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3372 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3373 "forgetLayerNormWeights",
"cellLayerNormWeights");
3377 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3378 "forgetLayerNormWeights",
"outputLayerNormWeights");
3384 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3385 "forgetLayerNormWeights",
"inputLayerNormWeights");
3390 bool correctProjectionTensorsPresent =
3395 if (!correctProjectionTensorsPresent)
3398 ": If projection is enabled, ProjectionWeights should be present and "
3399 "ProjectionBias is optional. If projection is disabled, neither "
3400 "ProjectionWeights nor ProjectionBias should be present.");
3407 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3413 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3420 ": If projection is disabled, output quantization info (scale, offset) "
3421 "should match HiddenStateScale and HiddenStateZeroPoint.");
3428 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3431 ValidateNumInputs(workloadInfo, descriptorName, 3);
3432 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3442 std::vector<DataType> inputOutputSupportedTypes =
3447 std::vector<DataType> cellStateSupportedTypes =
3452 std::vector<DataType> weightsSupportedTypes =
3457 std::vector<DataType> biasSupportedTypes =
3463 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3464 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3465 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3467 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3468 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3471 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3472 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3473 "outputStateIn",
"outputStateOut");
3474 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3477 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3478 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3479 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3482 const uint32_t numBatches = inputInfo.
GetShape()[0];
3483 const uint32_t inputSize = inputInfo.
GetShape()[1];
3484 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3517 " RecurrentToForgetWeights");
3528 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3530 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3531 "inputToInputWeights",
"inputToForgetWeights");
3532 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3533 "inputToInputWeights",
"inputToCellWeights");
3534 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3535 "inputToInputWeights",
"inputToOutputWeights");
3537 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3538 "inputToInputWeights",
"recurrentToInputWeights");
3539 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3540 "inputToInputWeights",
"recurrentToForgeteights");
3541 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3542 "inputToInputWeights",
"recurrentToCellWeights");
3543 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3544 "inputToInputWeights",
"recurrentToOutputWeights");
3547 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3548 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3549 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3550 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3551 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3552 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3554 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3555 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3556 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3557 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3558 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3559 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3560 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3561 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3572 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3581 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3583 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3584 "inputGateBias",
"forgetGateBias");
3585 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3586 "inputGateBias",
"cellBias");
3587 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3588 "inputGateBias",
"outputGateBias");
3591 ValidateBiasTensorQuantization(inputGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3592 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3593 ValidateBiasTensorQuantization(cellBiasInfo, inputToInputWeightsInfo, descriptorName);
3594 ValidateBiasTensorQuantization(outputGateBiasInfo, inputToInputWeightsInfo, descriptorName);
3599 const std::string descriptorName{
"AbsQueueDescriptor"};
3601 ValidateNumInputs(workloadInfo, descriptorName, 1);
3602 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3607 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3609 std::vector<DataType> supportedTypes =
3620 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3621 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3626 const std::string descriptorName{
"SliceQueueDescriptor"};
3628 ValidateNumInputs(workloadInfo, descriptorName, 1);
3629 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3634 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3648 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3653 ": Length of size descriptor must equal rank " + std::to_string(rank));
3658 for (
unsigned int i = 0u; i < rank; ++i)
3669 for(
unsigned int i = 0u; i < rank; ++i)
3674 std::to_string(i) +
" exceeds input size.");
3681 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3683 ValidateNumInputs(workloadInfo, descriptorName, 1);
3684 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3692 std::vector<DataType> supportedTypes =
3702 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3703 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3705 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3713 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3721 "must be divisible by block size.");
3728 "must be divisible by the square of block size." );
3734 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3736 ValidateNumInputs(workloadInfo, descriptorName, 2);
3737 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3743 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3758 const std::string descriptorName{
"ElementwiseBinaryQueueDescriptor"};
3760 ValidateNumInputs(workloadInfo, descriptorName, 2);
3761 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3767 std::vector<DataType> supportedTypes =
3778 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
3779 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
3781 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input",
"output");
3782 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input",
"output");
3787 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3789 ValidateNumInputs(workloadInfo, descriptorName, 1);
3790 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3795 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3797 std::vector<DataType> supportedTypes =
3808 std::vector<DataType> logicalSupportedTypes =
3815 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3819 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3823 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3828 const std::string descriptorName{
"RankQueueDescriptor"};
3830 ValidateNumInputs(workloadInfo, descriptorName, 1);
3831 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3837 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3839 std::vector<DataType> supportedTypes =
3851 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3857 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3859 ValidateNumInputs(workloadInfo, descriptorName, 2);
3860 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3866 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3891 const std::string descriptorName{
"ReduceQueueDescriptor"};
3893 ValidateNumInputs(workloadInfo, descriptorName, 1);
3894 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3899 std::vector<DataType> supportedTypes =
3910 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3911 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3918 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3930 std::vector<DataType> supportedTypes =
3937 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3951 unsigned int batchIndx = 0;
3952 unsigned int inputIndx = 1;
3953 uint32_t timeStep = 1;
3954 unsigned int timeIndx = 1;
3974 descriptorName +
" input_0");
3977 descriptorName +
" input_1");
3980 descriptorName +
" input_2");
3984 descriptorName +
" output_0");
3990 (n_cell * n_input),
"InputLayerNormWeights");
3995 (n_cell * n_input),
"InputToForgetWeights");
3999 (n_cell * n_input),
"InputToCellWeights");
4004 (n_cell * n_output),
"RecurrentToInputWeights");
4009 (n_cell * n_output),
"RecurrentToForgetWeights");
4013 (n_cell * n_output),
"RecurrentToCellWeights");
4021 if (!cifg_weights_all_or_none)
4024 "RecurrentToInputWeights must either both be present (regular LSTM) "
4025 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
4032 n_cell,
"CellToInputWeights");
4037 n_cell,
"CellToForgetWeights");
4042 n_cell,
"CellToOutputWeights");
4046 bool peephole_weights_all_or_none =
4051 if (!peephole_weights_all_or_none)
4069 "must be present.");
4072 n_cell,
"InputGateBias");
4078 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
4087 (n_cell * n_output),
"ProjectionWeights");
4104 if (!projecton_tensors_consistent)
4137 "disabled but InputLayerNormWeights are not present");
4140 1, n_cell,
"InputLayerNormWeights");
4149 "ForgetLayerNormWeights");
4153 "OutputLayerNormWeights");
4157 "CellLayerNormWeights");
4163 "normalisation weights are present.");
4169 const std::string descriptorName{
"BatchMatMulDescriptor"};
4171 ValidateNumInputs(workloadInfo, descriptorName, 2);
4172 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4183 std::vector<DataType> supportedTypes =
4193 ValidateDataTypes(inputXInfoBeforeParams, supportedTypes, descriptorName);
4194 ValidateDataTypes(inputYInfoBeforeParams, supportedTypes, descriptorName);
4195 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
4197 if ((inputXInfoBeforeParams.GetNumDimensions() < 2) ||
4198 (inputYInfoBeforeParams.GetNumDimensions() < 2))
4210 ": Invalid descriptor parameters - Transpose and Adjoint "
4211 "cannot both be true for a given input tensor.");
4218 inputXInfoBeforeParams.GetShape()));
4223 inputXInfoBeforeParams.GetShape());
4224 if(inputXInfoBeforeParams.GetShape()[axesToMul.first] !=
4225 inputXInfoBeforeParams.GetShape()[axesToMul.second])
4228 ": Adjoint is set to true for input tensor X, but the axes to be adjointed are not square." );
4231 inputXInfoAfterParams = inputXInfoBeforeParams;
4235 inputXInfoAfterParams = inputXInfoBeforeParams;
4243 inputYInfoBeforeParams.GetShape()));
4248 inputYInfoBeforeParams.GetShape());
4249 if(inputYInfoBeforeParams.GetShape()[axesToMul.first] !=
4250 inputYInfoBeforeParams.GetShape()[axesToMul.second])
4253 ": Adjoint is set to true for input tensor Y, but the axes to be adjointed are not square." );
4256 inputYInfoAfterParams = inputYInfoBeforeParams;
4260 inputYInfoAfterParams = inputYInfoBeforeParams;
4270 ": Input tensor X does not have the correct "
4271 "number of dimensions for the Data Layout that it has been assigned.");
4287 ": Input tensor Y does not have the correct "
4288 "number of dimensions for the Data Layout that it has been assigned.");
4300 inputXInfoBeforeParams.GetShape());
4302 if(inputXInfoAfterParams.
GetShape()[axesXToMul.second]
4303 != inputYInfoAfterParams.
GetShape()[axesYToMul.first])
4306 ": The final axis of input tensor X must be the same size as "
4307 "the second last axis of input tensor Y.");
4320 ": Invalid input tensor data layout combination.");
4328 ": Invalid input tensor data layout combination.");
4334 unsigned int outputTensorDimSize = std::max(inputXInfoAfterParams.
GetNumDimensions(),
4336 if(outputTensorDimSize-2 > 0)
4345 auto doAxisExtension = [&](std::vector<unsigned int> axisIndices,
TensorInfo& ti)
4347 auto sizeDiff = (outputTensorDimSize-2) - axisIndices.size();
4349 for(
unsigned int i = 0; i < sizeDiff; i++)
4351 axisIndices.insert(axisIndices.begin(), 1);
4354 for(
unsigned int i = 0; i < ti.GetNumDimensions(); i++)
4356 ti.GetShape()[i] = inputXInfoAfterParams.
GetShape()[i];
4365 doAxisExtension(axesXNotMul, tiXNotMul);
4366 doAxisExtension(axesYNotMul, tiYNotMul);
4374 ValidateBroadcastTensorShapesMatch(tiXNotMul,
4385 const std::string& descriptorName{
"TileQueueDescriptor"};
4387 ValidateNumInputs(workloadInfo, descriptorName, 1);
4388 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4393 std::vector<DataType> supportedTypes =
4408 ": Multiples length is not same as the number of dimensions in Input.");
4411 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
4412 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);