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 return DataType::Signed32;
39 case DataType::QAsymmU8:
40 return DataType::Signed32;
41 case DataType::QSymmS8:
42 return DataType::Signed32;
43 case DataType::QSymmS16:
44 return DataType::Signed32;
47 return DataType::Float32;
57 std::string to_string(T value)
59 std::ostringstream os;
65 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
70 paramName +
" parameter must be set.");
75 void ValidateTensorShapesMatch(
const TensorInfo& first,
77 std::string
const& descName,
78 std::string
const& firstName,
79 std::string
const& secondName)
84 + firstName +
" & " + secondName +
" must have identical shapes");
89 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
94 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
100 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
105 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
113 void ValidateTensorNumElements(
const TensorInfo& tensor,
114 std::string
const& descName,
115 unsigned int numElements,
116 std::string
const& tensorName)
122 tensorName +
" tensor.");
128 const std::string& descName, std::string
const& tensorName)
137 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
142 ": Expected data type which supports per-axis quantization scheme but got " +
148 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
150 const std::string& descName,
151 std::string
const& firstName,
152 std::string
const& secondName)
164 if (firstDataType != secondDataType)
167 " must be of the same quantized type, " +
175 " must have the same quantization space, " +
184 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
187 const std::string& descName)
190 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void
192 constexpr
float tolerance = 0.0001f;
193 if (std::abs(biasScale - expectedScale) > tolerance)
196 ARMNN_LOG(warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
197 " for bias quantization scale (product of input and weight scales), but got " <<
198 biasScale <<
". Using scale provided.";
214 if (weightScales.size() != biasScales.size())
216 std::stringstream msg;
217 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, "
218 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
219 <<
", biases=" << biasScales.size();
223 for (
size_t i = 0ul; i < biasScales.size(); ++i)
226 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
238 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
239 unsigned int numExpected,
240 const std::string& descName,
241 const std::string& varName)
243 if (vec.empty() && numExpected > 0)
248 for (
unsigned int i = 0; i < numExpected; ++i)
258 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
261 std::string
const& descName,
262 std::string
const& firstName,
263 std::string
const& secondName)
270 + firstName +
" & " + secondName
271 +
" must have the same number of dimensions in order to be broadcasted");
274 std::vector<uint32_t> outputDims(numDims, 0u);
275 for (uint32_t i = 0; i < numDims; i++)
278 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
279 if (dimsNotEqual && dimsNotOne)
285 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
286 if (broadcastShape != output.
GetShape())
289 + firstName +
" & " + secondName
290 +
" does not match the output shape");
295 void ValidateDataTypes(
const TensorInfo& info,
296 const std::vector<armnn::DataType>& supportedTypes,
297 std::string
const& descName)
299 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(),
info.GetDataType());
300 if (iterator == supportedTypes.end())
307 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
309 std::string
const& descName,
310 std::string
const& firstName,
311 std::string
const& secondName)
316 " must have identical data types.");
321 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
323 std::string
const& descName,
324 std::string
const& firstName,
325 std::string
const& secondName)
330 " must have the same number of elements.");
334 void ValidateWeightDataType(
const TensorInfo& inputInfo,
336 const std::string& descName)
341 const std::vector<DataType> validTypes =
348 ValidateDataTypes(weightInfo, validTypes, descName);
352 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
356 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
357 const std::string& descName,
358 const std::string& tensorName)
364 "not set on tensor {1}.", descName, tensorName));
368 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
369 const std::string& descName,
370 const std::string& tensorName)
373 if (quantizationOffset != 0)
376 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
377 descName, tensorName, quantizationOffset));
381 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
385 const std::string& descName)
392 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
394 if (!canHavePerAxisQuantization)
397 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support "
398 "per-axis quantization.", descName,
"weight"));
402 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
403 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
404 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
412 "{}: Per-axis quantization parameters not set on bias tensor, "
413 "despite being set on weight tensor.", descName));
416 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
417 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
418 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
427 std::string
const& descName,
428 unsigned int numDimensions,
429 std::string
const& tensorName)
const
436 unsigned int squeezedDims = 0;
445 if (tensor.
GetNumDimensions() < numDimensions || squeezedDims > numDimensions)
449 tensorName +
" tensor.");
458 tensorName +
" tensor.");
465 unsigned int numDimension,
466 unsigned int numElements,
467 std::string
const& tensorName)
const
469 const std::string functionName{
"ValidateTensorNumDimNumElem"};
471 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
476 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const
478 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
479 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
485 const std::string descriptorName{
"MapQueueDescriptor"};
487 ValidateNumInputs(workloadInfo, descriptorName, 1);
488 ValidateNumOutputs(workloadInfo, descriptorName, 0);
490 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
495 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
503 const std::string descriptorName{
"UnmapQueueDescriptor"};
505 ValidateNumInputs(workloadInfo, descriptorName, 1);
506 ValidateNumOutputs(workloadInfo, descriptorName, 0);
508 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
513 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
521 const std::string descriptorName{
"MemCopyQueueDescriptor"};
523 ValidateNumInputs(workloadInfo, descriptorName, 1);
524 ValidateNumOutputs(workloadInfo, descriptorName , 1);
529 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
530 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
535 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
539 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
544 "{0}: Invalid NULL input {1}.", descriptorName, i));
557 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
558 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
570 "Number of input infos ({0}) does not match the number of output infos ({1})",
580 "Number of elements for tensor input and output {} does not match", i ));
592 "Number of inputs ({0}) does not match the number of outputs ({1})",
596 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
613 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
634 const std::string descriptorName{
"ActivationQueueDescriptor"};
636 ValidateNumInputs(workloadInfo, descriptorName, 1);
637 ValidateNumOutputs(workloadInfo, descriptorName, 1);
642 std::vector<DataType> supportedTypes =
652 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
653 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
654 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
659 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
661 ValidateNumInputs(workloadInfo, descriptorName, 1);
662 ValidateNumOutputs(workloadInfo, descriptorName, 1);
673 std::vector<DataType> supportedInputTypes =
685 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
687 auto inputShape = inputTensorInfo.
GetShape();
688 auto outputShape = outputTensorInfo.
GetShape();
693 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
696 if (inputShape.GetNumDimensions() == 1)
698 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
705 for (
unsigned int i = 0; i < unsignedAxis; ++i)
707 if (outputShape[i] != inputShape[i])
713 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
715 if (outputShape[i - 1] != inputShape[i])
725 const std::string descriptorName{
"CastQueueDescriptor"};
727 ValidateNumInputs(workloadInfo, descriptorName, 1);
728 ValidateNumOutputs(workloadInfo, descriptorName, 1);
733 std::vector<DataType> supportedTypes =
746 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
747 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
752 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
754 ValidateNumInputs(workloadInfo, descriptorName, 1);
755 ValidateNumOutputs(workloadInfo, descriptorName, 1);
760 std::vector<DataType> supportedTypes =
770 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
771 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
772 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
777 const std::string descriptorName{
"SplitterQueueDescriptor"};
779 ValidateNumInputs(workloadInfo, descriptorName, 1);
782 std::vector<DataType> supportedTypes =
798 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
800 const std::string outputName =
"output_" + std::to_string(i);
801 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
812 descriptorName +
": Number of split windows "
813 "has to match number of workloadInfo.m_OutputTensorInfos. "
814 "Number of windows: " +
816 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
828 "have the same dimensionality as the input tensor. "
829 "Window origin (index: " +
830 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
831 " dimensions, the input "
833 to_string(inputDims) +
" dimensions.");
835 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
841 "be smaller or equal than the size of the input in that coord.");
849 const std::string descriptorName{
"ConcatQueueDescriptor"};
851 ValidateNumOutputs(workloadInfo, descriptorName, 1);
884 descriptorName +
": Number of split windows "
885 "has to match number of workloadInfo.m_InputTensorInfos. "
886 "Number of windows: " +
888 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
897 if (e.
m_Origin.size() != outputDims)
900 "have the same dimensionality as the output tensor. "
901 "Window origin (index: " +
902 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
903 " dimensions, the output "
905 to_string(outputDims) +
" dimensions.");
908 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
914 "be smaller or equal than the size of the output in that coord.");
920 std::vector<DataType> supportedTypes =
936 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
938 const std::string inputName =
"input_" + std::to_string(i);
939 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
945 const std::string descriptorName{
"StackQueueDescriptor"};
947 ValidateNumOutputs(workloadInfo, descriptorName, 1);
974 "than the number of input dimensions.");
981 if (outputShape[i] != inputShape[i])
984 "match shape inferred from input tensor.");
991 "match shape inferred from input tensor.");
996 if (outputShape[i] != inputShape[i-1])
999 "match shape inferred from input tensor.");
1009 std::vector<DataType> supportedTypes =
1021 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1029 "input_" + std::to_string(i));
1041 const std::string descriptorName{
"FillQueueDescriptor"};
1043 ValidateNumInputs(workloadInfo, descriptorName, 1);
1044 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1051 std::vector<DataType> supportedTypes =
1059 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1064 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1066 uint32_t numInputs = 2;
1072 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1073 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1092 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1098 std::vector<DataType> supportedTypes =
1108 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1116 "for BFloat16 input.");
1121 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1127 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1129 ValidateNumInputs(workloadInfo, descriptorName, 1);
1130 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1136 std::vector<DataType> supportedTypes =
1146 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1148 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1150 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1155 const std::string descriptorName{
"AdditionQueueDescriptor"};
1157 ValidateNumInputs(workloadInfo, descriptorName, 2);
1158 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1164 std::vector<DataType> supportedTypes =
1175 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1176 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1177 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1179 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1180 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1182 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1192 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1194 ValidateNumInputs(workloadInfo, descriptorName, 2);
1195 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1201 std::vector<DataType> supportedTypes =
1212 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1213 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1214 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1216 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1217 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1219 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1229 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1231 ValidateNumInputs(workloadInfo, descriptorName, 1);
1232 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1237 std::vector<DataType> supportedTypes =
1247 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1248 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1250 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1251 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1253 ValidatePointer(
m_Mean, descriptorName,
"mean");
1254 ValidatePointer(
m_Variance, descriptorName,
"variance");
1255 ValidatePointer(
m_Beta, descriptorName,
"beta");
1256 ValidatePointer(
m_Gamma, descriptorName,
"gamma");
1268 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1269 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1270 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1275 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1277 uint32_t numInputs = 2;
1283 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1284 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1296 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1301 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1305 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1311 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1312 "cannot be either negative or 0.",
1316 ValidatePerAxisQuantization(inputTensorInfo,
1319 optionalBiasTensorInfo,
1322 std::vector<DataType> supportedTypes =
1333 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1341 "for BFloat16 input.");
1346 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1352 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1354 uint32_t numInputs = 2;
1359 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1360 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1371 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1376 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1380 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1386 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})"
1387 "cannot be either negative or 0.",
1391 ValidatePerAxisQuantization(inputTensorInfo,
1394 optionalBiasTensorInfo,
1397 std::vector<DataType> supportedTypes =
1408 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1409 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1414 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1416 uint32_t numInputs = 2;
1422 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1423 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1437 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) "
1438 "cannot be smaller than 1.",
1445 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1446 "cannot be either negative or 0.",
1450 if (weightTensorInfo.
GetShape()[0] != 1)
1453 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
1454 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1463 const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.
GetShape()[3];
1464 const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.
GetShape()[1];
1465 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1468 bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
1469 bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
1471 if (!(validRefFormat || validAclFormat))
1474 "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] "
1475 "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is equal to Cout."
1476 "Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1485 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1490 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1493 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1496 ValidatePerAxisQuantization(inputTensorInfo,
1499 optionalBiasTensorInfo,
1502 std::vector<DataType> supportedTypes =
1512 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1513 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1518 const std::string descriptorName{
"PermuteQueueDescriptor"};
1520 ValidateNumInputs(workloadInfo, descriptorName, 1);
1521 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1531 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1533 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1536 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1537 "must match dst dimension " + to_string(mapping[i]) +
1538 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1542 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1547 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1549 ValidateNumInputs(workloadInfo, descriptorName, 1);
1550 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1558 std::vector<DataType> supportedTypes =
1568 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1569 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1574 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1576 ValidateNumInputs(workloadInfo, descriptorName, 1);
1577 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1585 std::vector<DataType> supportedTypes =
1595 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1596 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1601 const std::string descriptorName{
"ResizeQueueDescriptor"};
1603 ValidateNumInputs(workloadInfo, descriptorName, 1);
1604 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1612 std::vector<DataType> supportedTypes =
1622 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1623 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1626 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1627 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1628 if (inputBatchSize != outputBatchSize)
1631 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1632 descriptorName, inputBatchSize, outputBatchSize));
1638 if (inputChannelCount != outputChannelCount)
1641 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1642 descriptorName, inputChannelCount, outputChannelCount));
1648 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1650 ValidateNumInputs(workloadInfo, descriptorName, 1);
1651 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1659 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1669 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1671 ValidateNumInputs(workloadInfo, descriptorName, 1);
1672 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1682 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1685 std::vector<DataType> supportedTypes =
1692 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1693 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1698 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1700 ValidateNumInputs(workloadInfo, descriptorName, 1);
1701 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1711 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1714 std::vector<DataType> supportedTypes =
1724 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1725 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1730 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1732 ValidateNumInputs(workloadInfo, descriptorName, 1);
1733 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1738 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1740 std::vector<DataType> supportedTypes =
1747 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1748 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1753 const std::string descriptorName{
"ConstantQueueDescriptor"};
1755 ValidateNumInputs(workloadInfo, descriptorName, 0);
1756 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1767 std::vector<DataType> supportedTypes =
1779 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1784 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1786 ValidateNumInputs(workloadInfo, descriptorName, 1);
1787 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1792 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1795 std::vector<DataType> supportedTypes =
1807 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1808 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1813 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1815 ValidateNumInputs(workloadInfo, descriptorName, 1);
1816 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1832 "dimensions as Block Shape.");
1842 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1843 widthPad.first + widthPad.second;
1844 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1845 heightPad.first + heightPad.second;
1847 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1849 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1851 if (numOutputElements != numInputElements)
1854 to_string(numInputElements) +
" after padding but output tensor has " +
1855 to_string(numOutputElements) +
" elements.");
1861 "divisible by Block Shape in all spatial dimensions");
1864 std::vector<DataType> supportedTypes =
1874 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1875 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1880 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1882 ValidateNumInputs(workloadInfo, descriptorName, 1);
1883 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1891 std::vector<DataType> supportedTypes =
1901 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1902 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1904 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1912 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1920 "by block size in all spatial dimensions");
1927 "must be divisible by the square of block size." );
1933 const std::string descriptorName{
"FloorQueueDescriptor"};
1935 ValidateNumInputs(workloadInfo, descriptorName, 1);
1936 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1941 std::vector<DataType> supportedTypes =
1949 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1950 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1951 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1952 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1959 const std::string descriptorName{
"LstmQueueDescriptor"};
1971 std::vector<DataType> supportedTypes =
1980 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1989 "input_" + std::to_string(i));
1996 "LstmQueueDescriptor",
1998 "output_" + std::to_string(i));
2023 descriptorName +
" input_0");
2026 descriptorName +
" input_1");
2029 descriptorName +
" input_2");
2033 descriptorName +
" output_0");
2036 descriptorName +
" output_1");
2039 descriptorName +
" output_2");
2042 descriptorName +
" output_3");
2048 (n_cell * n_input),
"InputLayerNormWeights");
2053 (n_cell * n_input),
"InputToForgetWeights");
2057 (n_cell * n_input),
"InputToCellWeights");
2062 (n_cell * n_output),
"RecurrentToInputWeights");
2067 (n_cell * n_output),
"RecurrentToForgetWeights");
2071 (n_cell * n_output),
"RecurrentToCellWeights");
2079 if (!cifg_weights_all_or_none)
2082 "RecurrentToInputWeights must either both be present (regular LSTM) "
2083 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
2090 n_cell,
"CellToInputWeights");
2095 n_cell,
"CellToForgetWeights");
2100 n_cell,
"CellToOutputWeights");
2104 bool peephole_weights_all_or_none =
2109 if (!peephole_weights_all_or_none)
2127 "must be present.");
2130 n_cell,
"InputGateBias");
2136 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
2145 (n_cell * n_output),
"ProjectionWeights");
2162 if (!projecton_tensors_consistent)
2195 "disabled but InputLayerNormWeights are not present");
2198 1, n_cell,
"InputLayerNormWeights");
2207 "ForgetLayerNormWeights");
2211 "OutputLayerNormWeights");
2215 "CellLayerNormWeights");
2221 "normalisation weights are present.");
2227 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2229 ValidateNumInputs(workloadInfo, descriptorName, 1);
2230 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2245 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2250 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2252 ValidateNumInputs(workloadInfo, descriptorName, 1);
2253 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2268 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2273 const std::string descriptorName{
"DivisionQueueDescriptor"};
2275 ValidateNumInputs(workloadInfo, descriptorName, 2);
2276 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2282 std::vector<DataType> supportedTypes =
2293 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2294 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2295 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2297 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2307 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2309 ValidateNumInputs(workloadInfo, descriptorName, 2);
2310 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2316 std::vector<DataType> supportedTypes =
2327 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2328 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2329 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2331 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2341 const std::string descriptorName{
"MaximumQueueDescriptor"};
2343 ValidateNumInputs(workloadInfo, descriptorName, 2);
2344 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2350 std::vector<DataType> supportedTypes =
2361 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2362 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2363 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2365 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2375 const std::string descriptorName{
"MeanQueueDescriptor"};
2377 ValidateNumInputs(workloadInfo, descriptorName, 1);
2378 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2383 std::vector<DataType> supportedTypes =
2395 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2396 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2408 unsigned int outputDim =
2412 outputDim > 0 ? outputDim : 1,
2419 const std::string descriptorName{
"PadQueueDescriptor"};
2421 ValidateNumInputs(workloadInfo, descriptorName, 1);
2422 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2433 "as there are dimensions in the input tensor that is " +
2441 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2443 ValidateNumInputs(workloadInfo, descriptorName, 1);
2444 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2449 std::vector<DataType> supportedTypes =
2460 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2470 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2472 ValidateNumInputs(workloadInfo, descriptorName, 1);
2473 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2478 std::vector<DataType> supportedTypes =
2488 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2489 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2494 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2496 ValidateNumInputs(workloadInfo, descriptorName, 1);
2497 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2502 std::vector<DataType> supportedTypes =
2512 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2513 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2515 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2551 const std::string descriptorName{
"MinimumQueueDescriptor"};
2553 ValidateNumInputs(workloadInfo, descriptorName, 2);
2554 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2560 std::vector<DataType> supportedTypes =
2571 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2572 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2573 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2575 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2585 const std::string descriptorName{
"DebugQueueDescriptor"};
2587 ValidateNumInputs(workloadInfo, descriptorName, 1);
2588 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2593 const std::string descriptorName{
"EqualQueueDescriptor"};
2595 ValidateNumInputs(workloadInfo, descriptorName, 2);
2596 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2602 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2617 const std::string descriptorName{
"GreaterQueueDescriptor"};
2619 ValidateNumInputs(workloadInfo, descriptorName, 2);
2620 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2626 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2641 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2643 ValidateNumInputs(workloadInfo, descriptorName, 1);
2644 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2649 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2651 std::vector<DataType> supportedTypes =
2661 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2662 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2667 const std::string descriptorName{
"GatherNdQueueDescriptor"};
2669 ValidateNumInputs(workloadInfo, descriptorName, 2);
2670 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2681 std::vector<DataType> supportedTypes =
2692 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2694 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2702 const std::string descriptorName{
"GatherQueueDescriptor"};
2704 ValidateNumInputs(workloadInfo, descriptorName, 2);
2705 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2716 std::vector<DataType> supportedTypes =
2727 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2729 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2737 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2739 ValidateNumInputs(workloadInfo, descriptorName, 2);
2765 const std::vector<DataType> supportedInputTypes =
2775 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2776 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2777 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2785 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2786 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2787 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2788 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2793 "must be positive and less than or equal to 1.");
2799 "should be equal to number of classes + 1.");
2805 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2807 ValidateNumInputs(workloadInfo, descriptorName, 1);
2808 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2813 std::vector<DataType> inputSupportedTypes =
2821 ValidateDataTypes(inputTensorInfo, inputSupportedTypes, descriptorName);
2823 std::vector<DataType> outputSupportedTypes =
2830 ValidateDataTypes(outputTensorInfo, outputSupportedTypes, descriptorName);
2835 const std::string& descriptorName{
"MergeQueueDescriptor"};
2837 ValidateNumInputs(workloadInfo, descriptorName, 2);
2838 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2844 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2845 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2847 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2848 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2853 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2855 ValidateNumInputs(workloadInfo, descriptorName, 1);
2856 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2861 std::vector<DataType> supportedTypes =
2874 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2880 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2882 ValidateNumInputs(workloadInfo, descriptorName, 2);
2883 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2891 std::vector<DataType> supportedTypes =
2900 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2901 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2903 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2904 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2906 ValidateTensorShapesMatch(inputTensorInfo0,
2912 ValidateTensorShapesMatch(inputTensorInfo0,
2926 const std::string& descriptorName{
"PreluQueueDescriptor"};
2928 ValidateNumInputs(workloadInfo, descriptorName, 2);
2929 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2935 std::vector<DataType> supportedTypes
2945 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2946 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2948 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2950 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2951 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2953 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2963 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2965 ValidateNumInputs(workloadInfo, descriptorName, 1);
2966 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2974 ValidatePointer(
m_Weight, descriptorName,
"weight");
2979 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2984 ValidatePointer(
m_Bias, descriptorName,
"bias");
2990 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2993 ValidatePerAxisQuantization(inputTensorInfo,
2996 optionalBiasTensorInfo,
2999 std::vector<DataType> supportedTypes =
3009 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3010 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3015 const std::string descriptorName{
"TransposeQueueDescriptor"};
3017 ValidateNumInputs(workloadInfo, descriptorName, 1);
3018 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3028 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3030 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3033 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3034 "must match dst dimension " + to_string(i) +
3035 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3039 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3044 const std::string descriptorName{
"TransposeQueueDescriptor"};
3046 ValidateNumInputs(workloadInfo, descriptorName, 1);
3047 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3052 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3057 const std::string descriptorName{
"QLstmQueueDescriptor"};
3060 ValidateNumInputs(workloadInfo, descriptorName, 3);
3061 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3073 std::vector<DataType> inputOutputSupportedTypes =
3078 std::vector<DataType> cellStateSupportedTypes =
3083 std::vector<DataType> weightsSupportedTypes =
3088 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3093 std::vector<DataType> biasSupportedTypes =
3099 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3100 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3101 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3103 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3104 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3105 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3108 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3109 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3110 "outputStateIn",
"outputStateOut");
3111 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3114 const uint32_t numBatches = inputInfo.
GetShape()[0];
3115 const uint32_t inputSize = inputInfo.
GetShape()[1];
3116 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3117 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3144 " RecurrentToForgetWeights");
3155 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3157 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3158 "inputToForgetWeights",
"inputToCellWeights");
3159 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3160 "inputToForgetWeights",
"inputToOutputWeights");
3162 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3163 "inputToForgetWeights",
"recurrentToForgeteights");
3164 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3165 "inputToForgetWeights",
"recurrentToCellWeights");
3166 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3167 "inputToForgetWeights",
"recurrentToOutputWeights");
3174 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3183 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3185 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3186 "forgetGateBias",
"cellBias");
3187 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3188 "forgetGateBias",
"outputGateBias");
3196 if (!allCifgParamsPresentOrNot)
3199 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present "
3200 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be "
3201 "set appropriately.");
3212 " RecurrentToInputWeights");
3218 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3219 "inputToForgetWeights",
"inputToInputWeights");
3220 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3221 "inputToForgetWeights",
"recurrentToInputWeights");
3222 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3223 "forgetGateBias",
"inputGateBias");
3227 bool allPeepholeWeightsPresentOrNot =
3233 if (!allPeepholeWeightsPresentOrNot)
3236 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole "
3237 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present "
3238 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set "
3246 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3250 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3251 "cellToForgetWeight",
"cellToOutputWeights");
3257 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3258 "cellToForgetWeights",
"cellToInputWeights");
3263 bool allLayerNormWeightsPresentOrNot =
3269 if (!allLayerNormWeightsPresentOrNot)
3272 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights "
3273 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not "
3274 "be present at all (Layer Norm disabled). InputLayerNormWeights should "
3275 "only be present when Layer Norm is enabled and CIFG is disabled. "
3276 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3283 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3287 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3288 "forgetLayerNormWeights",
"cellLayerNormWeights");
3292 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3293 "forgetLayerNormWeights",
"outputLayerNormWeights");
3299 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3300 "forgetLayerNormWeights",
"inputLayerNormWeights");
3305 bool correctProjectionTensorsPresent =
3310 if (!correctProjectionTensorsPresent)
3313 ": If projection is enabled, ProjectionWeights should be present and "
3314 "ProjectionBias is optional. If projection is disabled, neither "
3315 "ProjectionWeights nor ProjectionBias should be present.");
3322 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3328 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3335 ": If projection is disabled, output quantization info (scale, offset) "
3336 "should match HiddenStateScale and HiddenStateZeroPoint.");
3343 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3346 ValidateNumInputs(workloadInfo, descriptorName, 3);
3347 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3357 std::vector<DataType> inputOutputSupportedTypes =
3362 std::vector<DataType> cellStateSupportedTypes =
3367 std::vector<DataType> weightsSupportedTypes =
3372 std::vector<DataType> biasSupportedTypes =
3378 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3379 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3380 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3382 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3383 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3386 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3387 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3388 "outputStateIn",
"outputStateOut");
3389 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3392 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3393 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3394 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3397 const uint32_t numBatches = inputInfo.
GetShape()[0];
3398 const uint32_t inputSize = inputInfo.
GetShape()[1];
3399 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3432 " RecurrentToForgetWeights");
3443 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3445 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3446 "inputToInputWeights",
"inputToForgetWeights");
3447 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3448 "inputToInputWeights",
"inputToCellWeights");
3449 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3450 "inputToInputWeights",
"inputToOutputWeights");
3452 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3453 "inputToInputWeights",
"recurrentToInputWeights");
3454 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3455 "inputToInputWeights",
"recurrentToForgeteights");
3456 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3457 "inputToInputWeights",
"recurrentToCellWeights");
3458 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3459 "inputToInputWeights",
"recurrentToOutputWeights");
3462 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3463 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3464 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3465 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3466 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3467 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3469 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3470 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3471 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3472 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3473 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3474 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3475 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3476 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3487 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3496 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3498 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3499 "inputGateBias",
"forgetGateBias");
3500 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3501 "inputGateBias",
"cellBias");
3502 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3503 "inputGateBias",
"outputGateBias");
3506 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3507 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3508 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3509 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3514 const std::string descriptorName{
"AbsQueueDescriptor"};
3516 ValidateNumInputs(workloadInfo, descriptorName, 1);
3517 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3522 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3524 std::vector<DataType> supportedTypes =
3535 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3536 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3541 const std::string descriptorName{
"SliceQueueDescriptor"};
3543 ValidateNumInputs(workloadInfo, descriptorName, 1);
3544 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3549 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3563 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3568 ": Length of size descriptor must equal rank " + std::to_string(rank));
3573 for (
unsigned int i = 0u; i < rank; ++i)
3584 for(
unsigned int i = 0u; i < rank; ++i)
3589 std::to_string(i) +
" exceeds input size.");
3596 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3598 ValidateNumInputs(workloadInfo, descriptorName, 1);
3599 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3607 std::vector<DataType> supportedTypes =
3617 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3618 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3620 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3628 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3636 "must be divisible by block size.");
3643 "must be divisible by the square of block size." );
3649 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3651 ValidateNumInputs(workloadInfo, descriptorName, 2);
3652 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3658 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3673 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3675 ValidateNumInputs(workloadInfo, descriptorName, 1);
3676 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3681 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3683 std::vector<DataType> supportedTypes =
3694 std::vector<DataType> logicalSupportedTypes =
3701 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3705 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3709 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3714 const std::string descriptorName{
"RankQueueDescriptor"};
3716 ValidateNumInputs(workloadInfo, descriptorName, 1);
3717 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3723 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3725 std::vector<DataType> supportedTypes =
3737 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3743 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3745 ValidateNumInputs(workloadInfo, descriptorName, 2);
3746 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3752 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3777 const std::string descriptorName{
"ReduceQueueDescriptor"};
3779 ValidateNumInputs(workloadInfo, descriptorName, 1);
3780 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3785 std::vector<DataType> supportedTypes =
3796 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3797 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3804 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3816 std::vector<DataType> supportedTypes =
3823 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3837 unsigned int batchIndx = 0;
3838 unsigned int inputIndx = 1;
3839 uint32_t timeStep = 1;
3840 unsigned int timeIndx = 1;
3860 descriptorName +
" input_0");
3863 descriptorName +
" input_1");
3866 descriptorName +
" input_2");
3870 descriptorName +
" output_0");
3876 (n_cell * n_input),
"InputLayerNormWeights");
3881 (n_cell * n_input),
"InputToForgetWeights");
3885 (n_cell * n_input),
"InputToCellWeights");
3890 (n_cell * n_output),
"RecurrentToInputWeights");
3895 (n_cell * n_output),
"RecurrentToForgetWeights");
3899 (n_cell * n_output),
"RecurrentToCellWeights");
3907 if (!cifg_weights_all_or_none)
3910 "RecurrentToInputWeights must either both be present (regular LSTM) "
3911 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
3918 n_cell,
"CellToInputWeights");
3923 n_cell,
"CellToForgetWeights");
3928 n_cell,
"CellToOutputWeights");
3932 bool peephole_weights_all_or_none =
3937 if (!peephole_weights_all_or_none)
3955 "must be present.");
3958 n_cell,
"InputGateBias");
3964 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
3973 (n_cell * n_output),
"ProjectionWeights");
3990 if (!projecton_tensors_consistent)
4023 "disabled but InputLayerNormWeights are not present");
4026 1, n_cell,
"InputLayerNormWeights");
4035 "ForgetLayerNormWeights");
4039 "OutputLayerNormWeights");
4043 "CellLayerNormWeights");
4049 "normalisation weights are present.");
4055 const std::string descriptorName{
"BatchMatMulDescriptor"};
4057 ValidateNumInputs(workloadInfo, descriptorName, 2);
4058 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4069 std::vector<DataType> supportedTypes =
4079 ValidateDataTypes(inputXInfoBeforeParams, supportedTypes, descriptorName);
4080 ValidateDataTypes(inputYInfoBeforeParams, supportedTypes, descriptorName);
4081 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
4083 if ((inputXInfoBeforeParams.GetNumDimensions() < 2) ||
4084 (inputYInfoBeforeParams.GetNumDimensions() < 2))
4096 ": Invalid descriptor parameters - Transpose and Adjoint "
4097 "cannot both be true for a given input tensor.");
4104 inputXInfoBeforeParams.GetShape()));
4109 inputXInfoBeforeParams.GetShape());
4110 if(inputXInfoBeforeParams.GetShape()[axesToMul.first] !=
4111 inputXInfoBeforeParams.GetShape()[axesToMul.second])
4114 ": Adjoint is set to true for input tensor X, but the axes to be adjointed are not square." );
4117 inputXInfoAfterParams = inputXInfoBeforeParams;
4121 inputXInfoAfterParams = inputXInfoBeforeParams;
4129 inputYInfoBeforeParams.GetShape()));
4134 inputYInfoBeforeParams.GetShape());
4135 if(inputYInfoBeforeParams.GetShape()[axesToMul.first] !=
4136 inputYInfoBeforeParams.GetShape()[axesToMul.second])
4139 ": Adjoint is set to true for input tensor Y, but the axes to be adjointed are not square." );
4142 inputYInfoAfterParams = inputYInfoBeforeParams;
4146 inputYInfoAfterParams = inputYInfoBeforeParams;
4156 ": Input tensor X does not have the correct "
4157 "number of dimensions for the Data Layout that it has been assigned.");
4173 ": Input tensor Y does not have the correct "
4174 "number of dimensions for the Data Layout that it has been assigned.");
4186 inputXInfoBeforeParams.GetShape());
4188 if(inputXInfoAfterParams.
GetShape()[axesXToMul.second]
4189 != inputYInfoAfterParams.
GetShape()[axesYToMul.first])
4192 ": The final axis of input tensor X must be the same size as "
4193 "the second last axis of input tensor Y.");
4206 ": Invalid input tensor data layout combination.");
4214 ": Invalid input tensor data layout combination.");
4220 unsigned int outputTensorDimSize = std::max(inputXInfoAfterParams.
GetNumDimensions(),
4222 if(outputTensorDimSize-2 > 0)
4231 auto doAxisExtension = [&](std::vector<unsigned int> axisIndices,
TensorInfo& ti)
4233 auto sizeDiff = (outputTensorDimSize-2) - axisIndices.size();
4235 for(
unsigned int i = 0; i < sizeDiff; i++)
4237 axisIndices.insert(axisIndices.begin(), 1);
4240 for(
unsigned int i = 0; i < ti.GetNumDimensions(); i++)
4242 ti.GetShape()[i] = inputXInfoAfterParams.
GetShape()[i];
4251 doAxisExtension(axesXNotMul, tiXNotMul);
4252 doAxisExtension(axesYNotMul, tiYNotMul);
4260 ValidateBroadcastTensorShapesMatch(tiXNotMul,