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,
184 const std::string& descName)
187 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void
189 constexpr
float tolerance = 0.0001f;
190 if (std::abs(biasScale - expectedScale) > tolerance)
193 ARMNN_LOG(warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
194 " for bias quantization scale (product of input and weight scales), but got " <<
195 biasScale <<
". Using scale provided.";
211 if (weightScales.size() != biasScales.size())
213 std::stringstream msg;
214 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, "
215 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
216 <<
", biases=" << biasScales.size();
220 for (
size_t i = 0ul; i < biasScales.size(); ++i)
223 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
235 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
236 unsigned int numExpected,
237 const std::string& descName,
238 const std::string& varName)
240 if (vec.empty() && numExpected > 0)
245 for (
unsigned int i = 0; i < numExpected; ++i)
255 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
258 std::string
const& descName,
259 std::string
const& firstName,
260 std::string
const& secondName)
267 + firstName +
" & " + secondName
268 +
" must have the same number of dimensions in order to be broadcasted");
271 std::vector<uint32_t> outputDims(numDims, 0u);
272 for (uint32_t i = 0; i < numDims; i++)
275 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
276 if (dimsNotEqual && dimsNotOne)
282 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
283 if (broadcastShape != output.
GetShape())
286 + firstName +
" & " + secondName
287 +
" does not match the output shape");
292 void ValidateDataTypes(
const TensorInfo& info,
293 const std::vector<armnn::DataType>& supportedTypes,
294 std::string
const& descName)
296 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(),
info.GetDataType());
297 if (iterator == supportedTypes.end())
304 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
306 std::string
const& descName,
307 std::string
const& firstName,
308 std::string
const& secondName)
313 " must have identical data types.");
318 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
320 std::string
const& descName,
321 std::string
const& firstName,
322 std::string
const& secondName)
327 " must have the same number of elements.");
331 void ValidateWeightDataType(
const TensorInfo& inputInfo,
333 const std::string& descName)
338 const std::vector<DataType> validTypes =
345 ValidateDataTypes(weightInfo, validTypes, descName);
349 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
353 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
354 const std::string& descName,
355 const std::string& tensorName)
361 "not set on tensor {1}.", descName, tensorName));
365 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
366 const std::string& descName,
367 const std::string& tensorName)
370 if (quantizationOffset != 0)
373 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
374 descName, tensorName, quantizationOffset));
378 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
382 const std::string& descName)
389 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
391 if (!canHavePerAxisQuantization)
394 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support "
395 "per-axis quantization.", descName,
"weight"));
399 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
400 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
401 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
409 "{}: Per-axis quantization parameters not set on bias tensor, "
410 "despite being set on weight tensor.", descName));
413 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
414 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
415 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
424 std::string
const& descName,
425 unsigned int numDimensions,
426 std::string
const& tensorName)
const
433 unsigned int squeezedDims = 0;
442 if (tensor.
GetNumDimensions() < numDimensions || squeezedDims > numDimensions)
446 tensorName +
" tensor.");
455 tensorName +
" tensor.");
462 unsigned int numDimension,
463 unsigned int numElements,
464 std::string
const& tensorName)
const
466 const std::string functionName{
"ValidateTensorNumDimNumElem"};
468 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
473 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const
475 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
476 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
482 const std::string descriptorName{
"MapQueueDescriptor"};
484 ValidateNumInputs(workloadInfo, descriptorName, 1);
485 ValidateNumOutputs(workloadInfo, descriptorName, 0);
487 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
492 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
500 const std::string descriptorName{
"UnmapQueueDescriptor"};
502 ValidateNumInputs(workloadInfo, descriptorName, 1);
503 ValidateNumOutputs(workloadInfo, descriptorName, 0);
505 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
510 fmt::format(
"{}: Invalid NULL input {}.", descriptorName,
static_cast<int>(i)));
518 const std::string descriptorName{
"MemCopyQueueDescriptor"};
520 ValidateNumInputs(workloadInfo, descriptorName, 1);
521 ValidateNumOutputs(workloadInfo, descriptorName , 1);
526 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
527 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
532 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
536 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
541 "{0}: Invalid NULL input {1}.", descriptorName, i));
554 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
555 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
567 "Number of input infos ({0}) does not match the number of output infos ({1})",
577 "Number of elements for tensor input and output {} does not match", i ));
589 "Number of inputs ({0}) does not match the number of outputs ({1})",
593 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
610 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
631 const std::string descriptorName{
"ActivationQueueDescriptor"};
633 ValidateNumInputs(workloadInfo, descriptorName, 1);
634 ValidateNumOutputs(workloadInfo, descriptorName, 1);
639 std::vector<DataType> supportedTypes =
649 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
650 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
651 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
656 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
658 ValidateNumInputs(workloadInfo, descriptorName, 1);
659 ValidateNumOutputs(workloadInfo, descriptorName, 1);
670 std::vector<DataType> supportedInputTypes =
682 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
684 auto inputShape = inputTensorInfo.
GetShape();
685 auto outputShape = outputTensorInfo.
GetShape();
690 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
693 if (inputShape.GetNumDimensions() == 1)
695 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
702 for (
unsigned int i = 0; i < unsignedAxis; ++i)
704 if (outputShape[i] != inputShape[i])
710 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
712 if (outputShape[i - 1] != inputShape[i])
722 const std::string descriptorName{
"CastQueueDescriptor"};
724 ValidateNumInputs(workloadInfo, descriptorName, 1);
725 ValidateNumOutputs(workloadInfo, descriptorName, 1);
730 std::vector<DataType> supportedTypes =
743 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
744 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
749 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
751 ValidateNumInputs(workloadInfo, descriptorName, 1);
752 ValidateNumOutputs(workloadInfo, descriptorName, 1);
757 std::vector<DataType> supportedTypes =
767 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
768 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
769 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
774 const std::string descriptorName{
"SplitterQueueDescriptor"};
776 ValidateNumInputs(workloadInfo, descriptorName, 1);
779 std::vector<DataType> supportedTypes =
795 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
797 const std::string outputName =
"output_" + std::to_string(i);
798 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
809 descriptorName +
": Number of split windows "
810 "has to match number of workloadInfo.m_OutputTensorInfos. "
811 "Number of windows: " +
813 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
825 "have the same dimensionality as the input tensor. "
826 "Window origin (index: " +
827 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
828 " dimensions, the input "
830 to_string(inputDims) +
" dimensions.");
832 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
838 "be smaller or equal than the size of the input in that coord.");
846 const std::string descriptorName{
"ConcatQueueDescriptor"};
848 ValidateNumOutputs(workloadInfo, descriptorName, 1);
881 descriptorName +
": Number of split windows "
882 "has to match number of workloadInfo.m_InputTensorInfos. "
883 "Number of windows: " +
885 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
894 if (e.
m_Origin.size() != outputDims)
897 "have the same dimensionality as the output tensor. "
898 "Window origin (index: " +
899 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
900 " dimensions, the output "
902 to_string(outputDims) +
" dimensions.");
905 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
911 "be smaller or equal than the size of the output in that coord.");
917 std::vector<DataType> supportedTypes =
933 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
935 const std::string inputName =
"input_" + std::to_string(i);
936 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
942 const std::string descriptorName{
"StackQueueDescriptor"};
944 ValidateNumOutputs(workloadInfo, descriptorName, 1);
971 "than the number of input dimensions.");
978 if (outputShape[i] != inputShape[i])
981 "match shape inferred from input tensor.");
988 "match shape inferred from input tensor.");
993 if (outputShape[i] != inputShape[i-1])
996 "match shape inferred from input tensor.");
1006 std::vector<DataType> supportedTypes =
1018 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1026 "input_" + std::to_string(i));
1038 const std::string descriptorName{
"FillQueueDescriptor"};
1040 ValidateNumInputs(workloadInfo, descriptorName, 1);
1041 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1048 std::vector<DataType> supportedTypes =
1056 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1061 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1063 uint32_t numInputs = 2;
1069 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1070 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1089 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1095 std::vector<DataType> supportedTypes =
1105 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1113 "for BFloat16 input.");
1118 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1124 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1126 ValidateNumInputs(workloadInfo, descriptorName, 1);
1127 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1133 std::vector<DataType> supportedTypes =
1143 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1145 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1147 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1152 const std::string descriptorName{
"AdditionQueueDescriptor"};
1154 ValidateNumInputs(workloadInfo, descriptorName, 2);
1155 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1161 std::vector<DataType> supportedTypes =
1172 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1173 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1174 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1176 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1177 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1179 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1189 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1191 ValidateNumInputs(workloadInfo, descriptorName, 2);
1192 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1198 std::vector<DataType> supportedTypes =
1209 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1210 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1211 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1213 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1214 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1216 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1226 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1228 ValidateNumInputs(workloadInfo, descriptorName, 1);
1229 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1234 std::vector<DataType> supportedTypes =
1244 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1245 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1247 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1248 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1250 ValidatePointer(
m_Mean, descriptorName,
"mean");
1251 ValidatePointer(
m_Variance, descriptorName,
"variance");
1252 ValidatePointer(
m_Beta, descriptorName,
"beta");
1253 ValidatePointer(
m_Gamma, descriptorName,
"gamma");
1265 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1266 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1267 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1272 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1274 uint32_t numInputs = 2;
1280 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1281 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1293 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1298 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1302 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1308 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1309 "cannot be either negative or 0.",
1313 ValidatePerAxisQuantization(inputTensorInfo,
1316 optionalBiasTensorInfo,
1319 std::vector<DataType> supportedTypes =
1330 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1338 "for BFloat16 input.");
1343 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1349 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1351 uint32_t numInputs = 2;
1356 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1357 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1368 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1373 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1377 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1383 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})"
1384 "cannot be either negative or 0.",
1388 ValidatePerAxisQuantization(inputTensorInfo,
1391 optionalBiasTensorInfo,
1394 std::vector<DataType> supportedTypes =
1405 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1406 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1411 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1413 uint32_t numInputs = 2;
1419 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1420 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1434 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) "
1435 "cannot be smaller than 1.",
1442 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) "
1443 "cannot be either negative or 0.",
1447 if (weightTensorInfo.
GetShape()[0] != 1)
1450 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
1451 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1460 const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.
GetShape()[3];
1461 const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.
GetShape()[1];
1462 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1465 bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
1466 bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
1468 if (!(validRefFormat || validAclFormat))
1471 "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] "
1472 "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is equal to Cout."
1473 "Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1482 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1487 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1490 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1493 ValidatePerAxisQuantization(inputTensorInfo,
1496 optionalBiasTensorInfo,
1499 std::vector<DataType> supportedTypes =
1509 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1510 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1515 const std::string descriptorName{
"PermuteQueueDescriptor"};
1517 ValidateNumInputs(workloadInfo, descriptorName, 1);
1518 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1528 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1530 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1533 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1534 "must match dst dimension " + to_string(mapping[i]) +
1535 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1539 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1544 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1546 ValidateNumInputs(workloadInfo, descriptorName, 1);
1547 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1555 std::vector<DataType> supportedTypes =
1565 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1566 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1571 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1573 ValidateNumInputs(workloadInfo, descriptorName, 1);
1574 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1582 std::vector<DataType> supportedTypes =
1592 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1593 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1598 const std::string descriptorName{
"ResizeQueueDescriptor"};
1600 ValidateNumInputs(workloadInfo, descriptorName, 1);
1601 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1609 std::vector<DataType> supportedTypes =
1619 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1620 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1623 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1624 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1625 if (inputBatchSize != outputBatchSize)
1628 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1629 descriptorName, inputBatchSize, outputBatchSize));
1635 if (inputChannelCount != outputChannelCount)
1638 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1639 descriptorName, inputChannelCount, outputChannelCount));
1645 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1647 ValidateNumInputs(workloadInfo, descriptorName, 1);
1648 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1656 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1666 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1668 ValidateNumInputs(workloadInfo, descriptorName, 1);
1669 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1679 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1682 std::vector<DataType> supportedTypes =
1689 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1690 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1695 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1697 ValidateNumInputs(workloadInfo, descriptorName, 1);
1698 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1708 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1711 std::vector<DataType> supportedTypes =
1721 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1722 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1727 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1729 ValidateNumInputs(workloadInfo, descriptorName, 1);
1730 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1735 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1737 std::vector<DataType> supportedTypes =
1744 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1745 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1750 const std::string descriptorName{
"ConstantQueueDescriptor"};
1752 ValidateNumInputs(workloadInfo, descriptorName, 0);
1753 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1764 std::vector<DataType> supportedTypes =
1776 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1781 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1783 ValidateNumInputs(workloadInfo, descriptorName, 1);
1784 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1789 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1792 std::vector<DataType> supportedTypes =
1804 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1805 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1810 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1812 ValidateNumInputs(workloadInfo, descriptorName, 1);
1813 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1829 "dimensions as Block Shape.");
1839 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1840 widthPad.first + widthPad.second;
1841 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1842 heightPad.first + heightPad.second;
1844 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1846 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1848 if (numOutputElements != numInputElements)
1851 to_string(numInputElements) +
" after padding but output tensor has " +
1852 to_string(numOutputElements) +
" elements.");
1858 "divisible by Block Shape in all spatial dimensions");
1861 std::vector<DataType> supportedTypes =
1871 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1872 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1877 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1879 ValidateNumInputs(workloadInfo, descriptorName, 1);
1880 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1888 std::vector<DataType> supportedTypes =
1898 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1899 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1901 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1909 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1917 "by block size in all spatial dimensions");
1924 "must be divisible by the square of block size." );
1930 const std::string descriptorName{
"FloorQueueDescriptor"};
1932 ValidateNumInputs(workloadInfo, descriptorName, 1);
1933 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1938 std::vector<DataType> supportedTypes =
1946 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1947 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1948 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1949 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1956 const std::string descriptorName{
"LstmQueueDescriptor"};
1968 std::vector<DataType> supportedTypes =
1977 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1986 "input_" + std::to_string(i));
1993 "LstmQueueDescriptor",
1995 "output_" + std::to_string(i));
2020 descriptorName +
" input_0");
2023 descriptorName +
" input_1");
2026 descriptorName +
" input_2");
2030 descriptorName +
" output_0");
2033 descriptorName +
" output_1");
2036 descriptorName +
" output_2");
2039 descriptorName +
" output_3");
2045 (n_cell * n_input),
"InputLayerNormWeights");
2050 (n_cell * n_input),
"InputToForgetWeights");
2054 (n_cell * n_input),
"InputToCellWeights");
2059 (n_cell * n_output),
"RecurrentToInputWeights");
2064 (n_cell * n_output),
"RecurrentToForgetWeights");
2068 (n_cell * n_output),
"RecurrentToCellWeights");
2076 if (!cifg_weights_all_or_none)
2079 "RecurrentToInputWeights must either both be present (regular LSTM) "
2080 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
2087 n_cell,
"CellToInputWeights");
2092 n_cell,
"CellToForgetWeights");
2097 n_cell,
"CellToOutputWeights");
2101 bool peephole_weights_all_or_none =
2106 if (!peephole_weights_all_or_none)
2124 "must be present.");
2127 n_cell,
"InputGateBias");
2133 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
2142 (n_cell * n_output),
"ProjectionWeights");
2159 if (!projecton_tensors_consistent)
2192 "disabled but InputLayerNormWeights are not present");
2195 1, n_cell,
"InputLayerNormWeights");
2204 "ForgetLayerNormWeights");
2208 "OutputLayerNormWeights");
2212 "CellLayerNormWeights");
2218 "normalisation weights are present.");
2224 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2226 ValidateNumInputs(workloadInfo, descriptorName, 1);
2227 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2242 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2247 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2249 ValidateNumInputs(workloadInfo, descriptorName, 1);
2250 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2265 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2270 const std::string descriptorName{
"DivisionQueueDescriptor"};
2272 ValidateNumInputs(workloadInfo, descriptorName, 2);
2273 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2279 std::vector<DataType> supportedTypes =
2290 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2291 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2292 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2294 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2304 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2306 ValidateNumInputs(workloadInfo, descriptorName, 2);
2307 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2313 std::vector<DataType> supportedTypes =
2324 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2325 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2326 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2328 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2338 const std::string descriptorName{
"MaximumQueueDescriptor"};
2340 ValidateNumInputs(workloadInfo, descriptorName, 2);
2341 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2347 std::vector<DataType> supportedTypes =
2358 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2359 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2360 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2362 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2372 const std::string descriptorName{
"MeanQueueDescriptor"};
2374 ValidateNumInputs(workloadInfo, descriptorName, 1);
2375 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2380 std::vector<DataType> supportedTypes =
2392 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2393 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2405 unsigned int outputDim =
2409 outputDim > 0 ? outputDim : 1,
2416 const std::string descriptorName{
"PadQueueDescriptor"};
2418 ValidateNumInputs(workloadInfo, descriptorName, 1);
2419 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2430 "as there are dimensions in the input tensor that is " +
2438 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2440 ValidateNumInputs(workloadInfo, descriptorName, 1);
2441 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2446 std::vector<DataType> supportedTypes =
2457 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2467 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2469 ValidateNumInputs(workloadInfo, descriptorName, 1);
2470 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2475 std::vector<DataType> supportedTypes =
2485 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2486 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2491 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2493 ValidateNumInputs(workloadInfo, descriptorName, 1);
2494 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2499 std::vector<DataType> supportedTypes =
2509 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2510 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2512 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2548 const std::string descriptorName{
"MinimumQueueDescriptor"};
2550 ValidateNumInputs(workloadInfo, descriptorName, 2);
2551 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2557 std::vector<DataType> supportedTypes =
2568 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2569 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2570 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2572 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2582 const std::string descriptorName{
"DebugQueueDescriptor"};
2584 ValidateNumInputs(workloadInfo, descriptorName, 1);
2585 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2590 const std::string descriptorName{
"EqualQueueDescriptor"};
2592 ValidateNumInputs(workloadInfo, descriptorName, 2);
2593 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2599 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2614 const std::string descriptorName{
"GreaterQueueDescriptor"};
2616 ValidateNumInputs(workloadInfo, descriptorName, 2);
2617 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2623 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2638 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2640 ValidateNumInputs(workloadInfo, descriptorName, 1);
2641 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2646 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2648 std::vector<DataType> supportedTypes =
2658 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2659 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2664 const std::string descriptorName{
"GatherNdQueueDescriptor"};
2666 ValidateNumInputs(workloadInfo, descriptorName, 2);
2667 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2678 std::vector<DataType> supportedTypes =
2689 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2691 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2699 const std::string descriptorName{
"GatherQueueDescriptor"};
2701 ValidateNumInputs(workloadInfo, descriptorName, 2);
2702 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2713 std::vector<DataType> supportedTypes =
2724 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2726 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2734 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2736 ValidateNumInputs(workloadInfo, descriptorName, 2);
2762 const std::vector<DataType> supportedInputTypes =
2772 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2773 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2774 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2782 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2783 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2784 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2785 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2790 "must be positive and less than or equal to 1.");
2796 "should be equal to number of classes + 1.");
2802 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2804 ValidateNumInputs(workloadInfo, descriptorName, 1);
2805 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2810 std::vector<DataType> inputSupportedTypes =
2818 ValidateDataTypes(inputTensorInfo, inputSupportedTypes, descriptorName);
2820 std::vector<DataType> outputSupportedTypes =
2827 ValidateDataTypes(outputTensorInfo, outputSupportedTypes, descriptorName);
2832 const std::string& descriptorName{
"MergeQueueDescriptor"};
2834 ValidateNumInputs(workloadInfo, descriptorName, 2);
2835 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2841 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2842 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2844 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2845 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2850 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2852 ValidateNumInputs(workloadInfo, descriptorName, 1);
2853 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2858 std::vector<DataType> supportedTypes =
2871 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2877 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2879 ValidateNumInputs(workloadInfo, descriptorName, 2);
2880 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2888 std::vector<DataType> supportedTypes =
2897 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2898 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2900 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2901 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2903 ValidateTensorShapesMatch(inputTensorInfo0,
2909 ValidateTensorShapesMatch(inputTensorInfo0,
2923 const std::string& descriptorName{
"PreluQueueDescriptor"};
2925 ValidateNumInputs(workloadInfo, descriptorName, 2);
2926 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2932 std::vector<DataType> supportedTypes
2942 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2943 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2945 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2947 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2948 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2950 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2960 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2962 ValidateNumInputs(workloadInfo, descriptorName, 1);
2963 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2971 ValidatePointer(
m_Weight, descriptorName,
"weight");
2976 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2981 ValidatePointer(
m_Bias, descriptorName,
"bias");
2987 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2990 ValidatePerAxisQuantization(inputTensorInfo,
2993 optionalBiasTensorInfo,
2996 std::vector<DataType> supportedTypes =
3006 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3007 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3012 const std::string descriptorName{
"TransposeQueueDescriptor"};
3014 ValidateNumInputs(workloadInfo, descriptorName, 1);
3015 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3025 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3027 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3030 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3031 "must match dst dimension " + to_string(i) +
3032 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3036 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3041 const std::string descriptorName{
"TransposeQueueDescriptor"};
3043 ValidateNumInputs(workloadInfo, descriptorName, 1);
3044 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3049 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3054 const std::string descriptorName{
"QLstmQueueDescriptor"};
3057 ValidateNumInputs(workloadInfo, descriptorName, 3);
3058 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3070 std::vector<DataType> inputOutputSupportedTypes =
3075 std::vector<DataType> cellStateSupportedTypes =
3080 std::vector<DataType> weightsSupportedTypes =
3085 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3090 std::vector<DataType> biasSupportedTypes =
3096 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3097 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3098 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3100 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3101 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3102 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3105 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3106 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3107 "outputStateIn",
"outputStateOut");
3108 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3111 const uint32_t numBatches = inputInfo.
GetShape()[0];
3112 const uint32_t inputSize = inputInfo.
GetShape()[1];
3113 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3114 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3141 " RecurrentToForgetWeights");
3152 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3154 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3155 "inputToForgetWeights",
"inputToCellWeights");
3156 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3157 "inputToForgetWeights",
"inputToOutputWeights");
3159 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3160 "inputToForgetWeights",
"recurrentToForgeteights");
3161 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3162 "inputToForgetWeights",
"recurrentToCellWeights");
3163 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3164 "inputToForgetWeights",
"recurrentToOutputWeights");
3171 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3180 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3182 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3183 "forgetGateBias",
"cellBias");
3184 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3185 "forgetGateBias",
"outputGateBias");
3193 if (!allCifgParamsPresentOrNot)
3196 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present "
3197 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be "
3198 "set appropriately.");
3209 " RecurrentToInputWeights");
3215 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3216 "inputToForgetWeights",
"inputToInputWeights");
3217 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3218 "inputToForgetWeights",
"recurrentToInputWeights");
3219 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3220 "forgetGateBias",
"inputGateBias");
3224 bool allPeepholeWeightsPresentOrNot =
3230 if (!allPeepholeWeightsPresentOrNot)
3233 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole "
3234 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present "
3235 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set "
3243 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3247 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3248 "cellToForgetWeight",
"cellToOutputWeights");
3254 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3255 "cellToForgetWeights",
"cellToInputWeights");
3260 bool allLayerNormWeightsPresentOrNot =
3266 if (!allLayerNormWeightsPresentOrNot)
3269 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights "
3270 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not "
3271 "be present at all (Layer Norm disabled). InputLayerNormWeights should "
3272 "only be present when Layer Norm is enabled and CIFG is disabled. "
3273 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3280 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3284 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3285 "forgetLayerNormWeights",
"cellLayerNormWeights");
3289 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3290 "forgetLayerNormWeights",
"outputLayerNormWeights");
3296 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3297 "forgetLayerNormWeights",
"inputLayerNormWeights");
3302 bool correctProjectionTensorsPresent =
3307 if (!correctProjectionTensorsPresent)
3310 ": If projection is enabled, ProjectionWeights should be present and "
3311 "ProjectionBias is optional. If projection is disabled, neither "
3312 "ProjectionWeights nor ProjectionBias should be present.");
3319 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3325 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3332 ": If projection is disabled, output quantization info (scale, offset) "
3333 "should match HiddenStateScale and HiddenStateZeroPoint.");
3340 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3343 ValidateNumInputs(workloadInfo, descriptorName, 3);
3344 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3354 std::vector<DataType> inputOutputSupportedTypes =
3359 std::vector<DataType> cellStateSupportedTypes =
3364 std::vector<DataType> weightsSupportedTypes =
3369 std::vector<DataType> biasSupportedTypes =
3375 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3376 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3377 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3379 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3380 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3383 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3384 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3385 "outputStateIn",
"outputStateOut");
3386 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3389 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3390 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3391 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3394 const uint32_t numBatches = inputInfo.
GetShape()[0];
3395 const uint32_t inputSize = inputInfo.
GetShape()[1];
3396 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3429 " RecurrentToForgetWeights");
3440 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3442 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3443 "inputToInputWeights",
"inputToForgetWeights");
3444 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3445 "inputToInputWeights",
"inputToCellWeights");
3446 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3447 "inputToInputWeights",
"inputToOutputWeights");
3449 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3450 "inputToInputWeights",
"recurrentToInputWeights");
3451 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3452 "inputToInputWeights",
"recurrentToForgeteights");
3453 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3454 "inputToInputWeights",
"recurrentToCellWeights");
3455 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3456 "inputToInputWeights",
"recurrentToOutputWeights");
3459 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3460 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3461 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3462 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3463 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3464 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3466 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3467 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3468 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3469 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3470 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3471 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3472 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3473 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3484 ValidatePointer(
m_CellBias, descriptorName,
"CellBias");
3493 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3495 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3496 "inputGateBias",
"forgetGateBias");
3497 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3498 "inputGateBias",
"cellBias");
3499 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3500 "inputGateBias",
"outputGateBias");
3503 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3504 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3505 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3506 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3511 const std::string descriptorName{
"AbsQueueDescriptor"};
3513 ValidateNumInputs(workloadInfo, descriptorName, 1);
3514 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3519 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3521 std::vector<DataType> supportedTypes =
3532 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3533 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3538 const std::string descriptorName{
"SliceQueueDescriptor"};
3540 ValidateNumInputs(workloadInfo, descriptorName, 1);
3541 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3546 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3560 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3565 ": Length of size descriptor must equal rank " + std::to_string(rank));
3570 for (
unsigned int i = 0u; i < rank; ++i)
3581 for(
unsigned int i = 0u; i < rank; ++i)
3586 std::to_string(i) +
" exceeds input size.");
3593 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3595 ValidateNumInputs(workloadInfo, descriptorName, 1);
3596 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3604 std::vector<DataType> supportedTypes =
3614 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3615 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3617 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3625 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3633 "must be divisible by block size.");
3640 "must be divisible by the square of block size." );
3646 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3648 ValidateNumInputs(workloadInfo, descriptorName, 2);
3649 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3655 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3670 const std::string descriptorName{
"ElementwiseBinaryQueueDescriptor"};
3672 ValidateNumInputs(workloadInfo, descriptorName, 2);
3673 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3679 std::vector<DataType> supportedTypes =
3690 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
3691 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
3693 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input",
"output");
3694 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input",
"output");
3699 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3701 ValidateNumInputs(workloadInfo, descriptorName, 1);
3702 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3707 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3709 std::vector<DataType> supportedTypes =
3720 std::vector<DataType> logicalSupportedTypes =
3727 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3731 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3735 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3740 const std::string descriptorName{
"RankQueueDescriptor"};
3742 ValidateNumInputs(workloadInfo, descriptorName, 1);
3743 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3749 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3751 std::vector<DataType> supportedTypes =
3763 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3769 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3771 ValidateNumInputs(workloadInfo, descriptorName, 2);
3772 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3778 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3803 const std::string descriptorName{
"ReduceQueueDescriptor"};
3805 ValidateNumInputs(workloadInfo, descriptorName, 1);
3806 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3811 std::vector<DataType> supportedTypes =
3822 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3823 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3830 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3842 std::vector<DataType> supportedTypes =
3849 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3863 unsigned int batchIndx = 0;
3864 unsigned int inputIndx = 1;
3865 uint32_t timeStep = 1;
3866 unsigned int timeIndx = 1;
3886 descriptorName +
" input_0");
3889 descriptorName +
" input_1");
3892 descriptorName +
" input_2");
3896 descriptorName +
" output_0");
3902 (n_cell * n_input),
"InputLayerNormWeights");
3907 (n_cell * n_input),
"InputToForgetWeights");
3911 (n_cell * n_input),
"InputToCellWeights");
3916 (n_cell * n_output),
"RecurrentToInputWeights");
3921 (n_cell * n_output),
"RecurrentToForgetWeights");
3925 (n_cell * n_output),
"RecurrentToCellWeights");
3933 if (!cifg_weights_all_or_none)
3936 "RecurrentToInputWeights must either both be present (regular LSTM) "
3937 "or both not present (CIFG-LSTM). In addition CifgEnable must be set "
3944 n_cell,
"CellToInputWeights");
3949 n_cell,
"CellToForgetWeights");
3954 n_cell,
"CellToOutputWeights");
3958 bool peephole_weights_all_or_none =
3963 if (!peephole_weights_all_or_none)
3981 "must be present.");
3984 n_cell,
"InputGateBias");
3990 ValidatePointer(
m_CellBias,
"Null pointer check",
"CellBias");
3999 (n_cell * n_output),
"ProjectionWeights");
4016 if (!projecton_tensors_consistent)
4049 "disabled but InputLayerNormWeights are not present");
4052 1, n_cell,
"InputLayerNormWeights");
4061 "ForgetLayerNormWeights");
4065 "OutputLayerNormWeights");
4069 "CellLayerNormWeights");
4075 "normalisation weights are present.");
4081 const std::string descriptorName{
"BatchMatMulDescriptor"};
4083 ValidateNumInputs(workloadInfo, descriptorName, 2);
4084 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4095 std::vector<DataType> supportedTypes =
4105 ValidateDataTypes(inputXInfoBeforeParams, supportedTypes, descriptorName);
4106 ValidateDataTypes(inputYInfoBeforeParams, supportedTypes, descriptorName);
4107 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
4109 if ((inputXInfoBeforeParams.GetNumDimensions() < 2) ||
4110 (inputYInfoBeforeParams.GetNumDimensions() < 2))
4122 ": Invalid descriptor parameters - Transpose and Adjoint "
4123 "cannot both be true for a given input tensor.");
4130 inputXInfoBeforeParams.GetShape()));
4135 inputXInfoBeforeParams.GetShape());
4136 if(inputXInfoBeforeParams.GetShape()[axesToMul.first] !=
4137 inputXInfoBeforeParams.GetShape()[axesToMul.second])
4140 ": Adjoint is set to true for input tensor X, but the axes to be adjointed are not square." );
4143 inputXInfoAfterParams = inputXInfoBeforeParams;
4147 inputXInfoAfterParams = inputXInfoBeforeParams;
4155 inputYInfoBeforeParams.GetShape()));
4160 inputYInfoBeforeParams.GetShape());
4161 if(inputYInfoBeforeParams.GetShape()[axesToMul.first] !=
4162 inputYInfoBeforeParams.GetShape()[axesToMul.second])
4165 ": Adjoint is set to true for input tensor Y, but the axes to be adjointed are not square." );
4168 inputYInfoAfterParams = inputYInfoBeforeParams;
4172 inputYInfoAfterParams = inputYInfoBeforeParams;
4182 ": Input tensor X does not have the correct "
4183 "number of dimensions for the Data Layout that it has been assigned.");
4199 ": Input tensor Y does not have the correct "
4200 "number of dimensions for the Data Layout that it has been assigned.");
4212 inputXInfoBeforeParams.GetShape());
4214 if(inputXInfoAfterParams.
GetShape()[axesXToMul.second]
4215 != inputYInfoAfterParams.
GetShape()[axesYToMul.first])
4218 ": The final axis of input tensor X must be the same size as "
4219 "the second last axis of input tensor Y.");
4232 ": Invalid input tensor data layout combination.");
4240 ": Invalid input tensor data layout combination.");
4246 unsigned int outputTensorDimSize = std::max(inputXInfoAfterParams.
GetNumDimensions(),
4248 if(outputTensorDimSize-2 > 0)
4257 auto doAxisExtension = [&](std::vector<unsigned int> axisIndices,
TensorInfo& ti)
4259 auto sizeDiff = (outputTensorDimSize-2) - axisIndices.size();
4261 for(
unsigned int i = 0; i < sizeDiff; i++)
4263 axisIndices.insert(axisIndices.begin(), 1);
4266 for(
unsigned int i = 0; i < ti.GetNumDimensions(); i++)
4268 ti.GetShape()[i] = inputXInfoAfterParams.
GetShape()[i];
4277 doAxisExtension(axesXNotMul, tiXNotMul);
4278 doAxisExtension(axesYNotMul, tiYNotMul);
4286 ValidateBroadcastTensorShapesMatch(tiXNotMul,