18 #include <fmt/format.h> 28 switch (inputDataType)
30 case DataType::Float16:
31 return DataType::Float16;
33 case DataType::Float32:
34 return DataType::Float32;
35 case DataType::QAsymmS8:
36 return DataType::Signed32;
37 case DataType::QAsymmU8:
38 return DataType::Signed32;
39 case DataType::QSymmS8:
40 return DataType::Signed32;
41 case DataType::QSymmS16:
42 return DataType::Signed32;
45 return DataType::Float32;
55 std::string to_string(T value)
57 std::ostringstream os;
63 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
68 paramName +
" parameter must be set.");
73 void ValidateTensorShapesMatch(
const TensorInfo& first,
75 std::string
const& descName,
76 std::string
const& firstName,
77 std::string
const& secondName)
82 + firstName +
" & " + secondName +
" must have identical shapes");
87 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
92 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
98 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
103 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
109 void ValidateTensorNumDimensions(
const TensorInfo& tensor,
110 std::string
const& descName,
111 unsigned int numDimensions,
112 std::string
const& tensorName)
118 tensorName +
" tensor.");
123 void ValidateTensorNumElements(
const TensorInfo& tensor,
124 std::string
const& descName,
125 unsigned int numElements,
126 std::string
const& tensorName)
132 tensorName +
" tensor.");
137 void ValidateTensorNumDimNumElem(
const TensorInfo& tensorInfo,
138 unsigned int numDimension,
139 unsigned int numElements,
140 std::string
const& tensorName)
142 const std::string functionName{
"ValidateTensorNumDimNumElem"};
143 ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName);
144 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
149 const std::string& descName, std::string
const& tensorName)
158 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
162 tensor.
GetDataType() != DataType::QuantizedSymm8PerAxis)
165 ": Expected data type which supports per-axis quantization scheme but got " +
172 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
174 const std::string& descName,
175 std::string
const& firstName,
176 std::string
const& secondName)
188 if (firstDataType != secondDataType)
191 " must be of the same quantized type, " +
199 " must have the same quantization space, " +
208 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
211 const std::string& descName)
214 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 216 constexpr
float tolerance = 0.0001f;
217 if (std::abs(biasScale - expectedScale) > tolerance)
220 ARMNN_LOG(
warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
221 " for bias quantization scale (product of input and weight scales), but got " <<
222 biasScale <<
". Using scale provided.";
238 if (weightScales.size() != biasScales.size())
240 std::stringstream msg;
241 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, " 242 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
243 <<
", biases=" << biasScales.size();
247 for (
size_t i = 0ul; i < biasScales.size(); ++i)
250 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
262 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
263 unsigned int numExpected,
264 const std::string& descName,
265 const std::string& varName)
267 if (vec.empty() && numExpected > 0)
272 for (
unsigned int i = 0; i < numExpected; ++i)
282 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
285 std::string
const& descName,
286 std::string
const& firstName,
287 std::string
const& secondName)
294 + firstName +
" & " + secondName
295 +
" must have the same number of dimensions in order to be broadcasted");
298 std::vector<uint32_t> outputDims(numDims, 0u);
299 for (uint32_t i = 0; i < numDims; i++)
302 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
303 if (dimsNotEqual && dimsNotOne)
309 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
310 if (broadcastShape != output.
GetShape())
313 + firstName +
" & " + secondName
314 +
" does not match the output shape");
320 const std::vector<armnn::DataType>& supportedTypes,
321 std::string
const& descName)
323 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
324 if (iterator == supportedTypes.end())
331 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
333 std::string
const& descName,
334 std::string
const& firstName,
335 std::string
const& secondName)
340 " must have identical data types.");
345 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
347 std::string
const& descName,
348 std::string
const& firstName,
349 std::string
const& secondName)
354 " must have the same number of elements.");
358 void ValidateWeightDataType(
const TensorInfo& inputInfo,
360 const std::string& descName)
366 const std::vector<DataType> validTypes =
371 DataType::QuantizedSymm8PerAxis
375 ValidateDataTypes(weightInfo, validTypes, descName);
379 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
383 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
384 const std::string& descName,
385 const std::string& tensorName)
391 "not set on tensor {1}.", descName, tensorName));
395 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
396 const std::string& descName,
397 const std::string& tensorName)
400 if (quantizationOffset != 0)
403 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
404 descName, tensorName, quantizationOffset));
408 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
412 const std::string& descName)
419 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
421 if (!canHavePerAxisQuantization)
424 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 425 "per-axis quantization.", descName,
"weight"));
429 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
430 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
431 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
439 "{}: Per-axis quantization parameters not set on bias tensor, " 440 "despite being set on weight tensor.", descName));
443 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
444 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
445 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
453 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 455 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
456 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
462 const std::string descriptorName{
"MapQueueDescriptor"};
464 ValidateNumInputs(workloadInfo, descriptorName, 1);
465 ValidateNumOutputs(workloadInfo, descriptorName, 0);
467 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
472 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
480 const std::string descriptorName{
"UnmapQueueDescriptor"};
482 ValidateNumInputs(workloadInfo, descriptorName, 1);
483 ValidateNumOutputs(workloadInfo, descriptorName, 0);
485 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
490 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
498 const std::string descriptorName{
"MemCopyQueueDescriptor"};
500 ValidateNumInputs(workloadInfo, descriptorName, 1);
501 ValidateNumOutputs(workloadInfo, descriptorName , 1);
506 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
507 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
512 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
516 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
521 "{0}: Invalid NULL input {1}.", descriptorName, i));
534 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
535 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
547 "Number of input infos ({0}) does not match the number of output infos ({1})",
557 "Number of elements for tensor input and output {} does not match", i ));
569 "Number of inputs ({0}) does not match the number of outputs ({1})",
573 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
590 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
591 ValidateNumOutputs(workloadInfo,
"MemSyncQueueDescriptor" , 1);
612 const std::string descriptorName{
"ActivationQueueDescriptor"};
614 ValidateNumInputs(workloadInfo, descriptorName, 1);
615 ValidateNumOutputs(workloadInfo, descriptorName, 1);
620 std::vector<DataType> supportedTypes =
630 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
631 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
632 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
637 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
639 ValidateNumInputs(workloadInfo, descriptorName, 1);
640 ValidateNumOutputs(workloadInfo, descriptorName, 1);
651 std::vector<DataType> supportedInputTypes =
663 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
665 auto inputShape = inputTensorInfo.
GetShape();
666 auto outputShape = outputTensorInfo.
GetShape();
671 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
674 if (inputShape.GetNumDimensions() == 1)
676 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
683 for (
unsigned int i = 0; i < unsignedAxis; ++i)
685 if (outputShape[i] != inputShape[i])
691 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
693 if (outputShape[i - 1] != inputShape[i])
703 const std::string descriptorName{
"CastQueueDescriptor"};
705 ValidateNumInputs(workloadInfo, descriptorName, 1);
706 ValidateNumOutputs(workloadInfo, descriptorName, 1);
711 std::vector<DataType> supportedTypes =
724 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
725 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
730 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
732 ValidateNumInputs(workloadInfo, descriptorName, 1);
733 ValidateNumOutputs(workloadInfo, descriptorName, 1);
738 std::vector<DataType> supportedTypes =
748 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
749 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
750 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
755 const std::string descriptorName{
"SplitterQueueDescriptor"};
757 ValidateNumInputs(workloadInfo, descriptorName, 1);
760 std::vector<DataType> supportedTypes =
776 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
778 const std::string outputName =
"output_" + std::to_string(i);
779 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
790 descriptorName +
": Number of split windows " 791 "has to match number of workloadInfo.m_OutputTensorInfos. " 792 "Number of windows: " +
793 to_string(m_ViewOrigins.size()) +
794 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
799 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
806 "have the same dimensionality as the input tensor. " 807 "Window origin (index: " +
808 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
809 " dimensions, the input " 811 to_string(inputDims) +
" dimensions.");
813 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
819 "be smaller or equal than the size of the input in that coord.");
827 const std::string descriptorName{
"ConcatQueueDescriptor"};
829 ValidateNumOutputs(workloadInfo, descriptorName, 1);
849 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
854 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
862 descriptorName +
": Number of split windows " 863 "has to match number of workloadInfo.m_InputTensorInfos. " 864 "Number of windows: " +
865 to_string(m_ViewOrigins.size()) +
866 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
871 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
875 if (e.
m_Origin.size() != outputDims)
878 "have the same dimensionality as the output tensor. " 879 "Window origin (index: " +
880 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
881 " dimensions, the output " 883 to_string(outputDims) +
" dimensions.");
886 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
892 "be smaller or equal than the size of the output in that coord.");
898 std::vector<DataType> supportedTypes =
914 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
916 const std::string inputName =
"input_" + std::to_string(i);
917 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
923 const std::string descriptorName{
"StackQueueDescriptor"};
925 ValidateNumOutputs(workloadInfo, descriptorName, 1);
933 const TensorShape& inputShape = m_Parameters.m_InputShape;
952 "than the number of input dimensions.");
957 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
959 if (outputShape[i] != inputShape[i])
962 "match shape inferred from input tensor.");
966 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
969 "match shape inferred from input tensor.");
972 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
974 if (outputShape[i] != inputShape[i-1])
977 "match shape inferred from input tensor.");
987 std::vector<DataType> supportedTypes =
999 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1007 "input_" + std::to_string(i));
1019 const std::string descriptorName{
"FillQueueDescriptor"};
1021 ValidateNumInputs(workloadInfo, descriptorName, 1);
1022 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1027 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 1,
"input");
1029 std::vector<DataType> supportedTypes =
1037 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1042 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1044 uint32_t numInputs = 2;
1045 if (m_Parameters.m_BiasEnabled)
1050 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1051 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1056 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1064 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 2,
"weight");
1066 if (m_Parameters.m_BiasEnabled)
1070 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1072 ValidateTensorNumDimensions(biasTensorInfo, descriptorName, 1,
"bias");
1076 std::vector<DataType> supportedTypes =
1086 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1094 "for BFloat16 input.");
1099 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1105 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1107 ValidateNumInputs(workloadInfo, descriptorName, 1);
1108 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1114 std::vector<DataType> supportedTypes =
1124 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1126 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1128 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1133 const std::string descriptorName{
"AdditionQueueDescriptor"};
1135 ValidateNumInputs(workloadInfo, descriptorName, 2);
1136 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1142 std::vector<DataType> supportedTypes =
1153 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1154 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1155 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1157 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1158 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1160 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1170 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1172 ValidateNumInputs(workloadInfo, descriptorName, 2);
1173 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1179 std::vector<DataType> supportedTypes =
1190 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1191 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1192 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1194 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1195 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1197 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1207 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1209 ValidateNumInputs(workloadInfo, descriptorName, 1);
1210 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1215 std::vector<DataType> supportedTypes =
1225 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1226 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1228 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1229 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1231 ValidatePointer(m_Mean, descriptorName,
"mean");
1232 ValidatePointer(m_Variance, descriptorName,
"variance");
1233 ValidatePointer(m_Beta, descriptorName,
"beta");
1234 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1236 const TensorInfo& mean = m_Mean->GetTensorInfo();
1237 const TensorInfo& variance = m_Variance->GetTensorInfo();
1238 const TensorInfo& beta = m_Beta->GetTensorInfo();
1239 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1241 ValidateTensorNumDimensions(mean, descriptorName, 1,
"mean");
1242 ValidateTensorNumDimensions(variance, descriptorName, 1,
"variance");
1243 ValidateTensorNumDimensions(beta, descriptorName, 1,
"beta");
1244 ValidateTensorNumDimensions(gamma, descriptorName, 1,
"gamma");
1246 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1247 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1248 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1253 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1255 ValidateNumInputs(workloadInfo, descriptorName, 1);
1256 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1261 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1262 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1264 ValidatePointer(m_Weight, descriptorName,
"weight");
1266 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1267 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1269 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1272 if (m_Parameters.m_BiasEnabled)
1274 ValidatePointer(m_Bias, descriptorName,
"bias");
1276 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1280 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1283 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1286 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1287 "cannot be either negative or 0.",
1288 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1291 ValidatePerAxisQuantization(inputTensorInfo,
1294 optionalBiasTensorInfo,
1297 std::vector<DataType> supportedTypes =
1308 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1316 "for BFloat16 input.");
1321 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1327 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1329 ValidateNumInputs(workloadInfo, descriptorName, 1);
1330 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1335 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1336 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1338 ValidatePointer(m_Weight, descriptorName,
"weight");
1340 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1341 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1343 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1346 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) " 1347 "cannot be smaller than 1.",
1348 descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
1351 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1354 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1355 "cannot be either negative or 0.",
1356 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1359 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1363 const unsigned int numWeightOutputChannels = weightTensorInfo.
GetShape()[3];
1364 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1365 if (numWeightOutputChannels != numOutputChannels)
1368 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]." 1369 "But 4th dimension is not equal to Cout. Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1377 if (weightTensorInfo.
GetShape()[0] != 1)
1380 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]." 1381 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1389 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1392 if (m_Parameters.m_BiasEnabled)
1394 ValidatePointer(m_Bias, descriptorName,
"bias");
1396 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1399 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1402 ValidatePerAxisQuantization(inputTensorInfo,
1405 optionalBiasTensorInfo,
1408 std::vector<DataType> supportedTypes =
1418 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1419 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1424 const std::string descriptorName{
"PermuteQueueDescriptor"};
1426 ValidateNumInputs(workloadInfo, descriptorName, 1);
1427 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1434 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
1435 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
1437 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1439 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1442 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1443 "must match dst dimension " + to_string(mapping[i]) +
1444 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1448 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1453 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1455 ValidateNumInputs(workloadInfo, descriptorName, 1);
1456 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1461 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1462 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1464 std::vector<DataType> supportedTypes =
1474 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1475 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1480 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1482 ValidateNumInputs(workloadInfo, descriptorName, 1);
1483 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1488 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1489 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1491 std::vector<DataType> supportedTypes =
1501 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1502 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1505 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1506 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1507 if (inputBatchSize != outputBatchSize)
1510 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1511 descriptorName, inputBatchSize, outputBatchSize));
1517 if (inputChannelCount != outputChannelCount)
1520 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1521 descriptorName, inputChannelCount, outputChannelCount));
1527 const std::string descriptorName{
"ResizeQueueDescriptor"};
1529 ValidateNumInputs(workloadInfo, descriptorName, 1);
1530 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1535 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1536 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1538 std::vector<DataType> supportedTypes =
1548 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1549 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1552 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1553 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1554 if (inputBatchSize != outputBatchSize)
1557 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1558 descriptorName, inputBatchSize, outputBatchSize));
1564 if (inputChannelCount != outputChannelCount)
1567 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1568 descriptorName, inputChannelCount, outputChannelCount));
1574 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1576 ValidateNumInputs(workloadInfo, descriptorName, 1);
1577 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1582 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1583 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1585 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1587 if (m_Parameters.m_Min > m_Parameters.m_Max)
1595 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1597 ValidateNumInputs(workloadInfo, descriptorName, 1);
1598 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1608 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1611 std::vector<DataType> supportedTypes =
1618 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1619 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1624 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1626 ValidateNumInputs(workloadInfo, descriptorName, 1);
1627 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1637 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1640 std::vector<DataType> supportedTypes =
1650 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1651 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1656 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1658 ValidateNumInputs(workloadInfo, descriptorName, 1);
1659 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1664 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1666 std::vector<DataType> supportedTypes =
1673 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1674 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1679 const std::string descriptorName{
"ConstantQueueDescriptor"};
1681 ValidateNumInputs(workloadInfo, descriptorName, 0);
1682 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1690 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1693 std::vector<DataType> supportedTypes =
1705 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1710 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1712 ValidateNumInputs(workloadInfo, descriptorName, 1);
1713 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1718 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1721 std::vector<DataType> supportedTypes =
1733 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1734 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1739 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1741 ValidateNumInputs(workloadInfo, descriptorName, 1);
1742 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1747 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1748 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1750 if (m_Parameters.m_BlockShape.size() != 2)
1755 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1758 "dimensions as Block Shape.");
1763 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1764 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1768 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1769 widthPad.first + widthPad.second;
1770 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1771 heightPad.first + heightPad.second;
1773 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1775 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1777 if (numOutputElements != numInputElements)
1780 to_string(numInputElements) +
" after padding but output tensor has " +
1781 to_string(numOutputElements) +
" elements.");
1784 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1787 "divisible by Block Shape in all spatial dimensions");
1790 std::vector<DataType> supportedTypes =
1800 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1801 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1806 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1808 ValidateNumInputs(workloadInfo, descriptorName, 1);
1809 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1814 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1815 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1817 std::vector<DataType> supportedTypes =
1827 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1828 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1830 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1832 if (m_Parameters.m_BlockSize == 0)
1838 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1843 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1846 "by block size in all spatial dimensions");
1850 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1853 "must be divisible by the square of block size." );
1859 const std::string descriptorName{
"FloorQueueDescriptor"};
1861 ValidateNumInputs(workloadInfo, descriptorName, 1);
1862 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1867 std::vector<DataType> supportedTypes =
1875 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1876 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1877 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1878 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1885 const std::string descriptorName{
"LstmQueueDescriptor"};
1897 std::vector<DataType> supportedTypes =
1906 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1915 "input_" + std::to_string(i));
1922 "LstmQueueDescriptor",
1924 "output_" + std::to_string(i));
1930 if (m_Parameters.m_ClippingThresCell < 0.0f)
1934 if (m_Parameters.m_ClippingThresProj < 0.0f)
1942 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
1943 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
1944 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
1945 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
1948 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
1949 descriptorName +
" input_0");
1951 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
1952 descriptorName +
" input_1");
1954 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
1955 descriptorName +
" input_2");
1957 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
1958 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
1959 descriptorName +
" output_0");
1962 descriptorName +
" output_1");
1965 descriptorName +
" output_2");
1968 descriptorName +
" output_3");
1971 if ( m_InputToInputWeights )
1973 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
1974 (n_cell * n_input),
"InputLayerNormWeights");
1977 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
1978 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
1979 (n_cell * n_input),
"InputToForgetWeights");
1981 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
1982 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
1983 (n_cell * n_input),
"InputToCellWeights");
1985 if ( m_RecurrentToInputWeights )
1987 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
1988 (n_cell * n_output),
"RecurrentToInputWeights");
1991 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
1992 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
1993 (n_cell * n_output),
"RecurrentToForgetWeights");
1995 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
1996 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
1997 (n_cell * n_output),
"RecurrentToCellWeights");
2001 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
2002 !m_Parameters.m_CifgEnabled) ||
2003 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
2004 m_Parameters.m_CifgEnabled));
2005 if (!cifg_weights_all_or_none)
2008 "RecurrentToInputWeights must either both be present (regular LSTM) " 2009 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 2013 if ( m_CellToInputWeights )
2015 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
2016 n_cell,
"CellToInputWeights");
2018 if ( m_CellToForgetWeights )
2020 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
2021 n_cell,
"CellToForgetWeights");
2023 if ( m_CellToOutputWeights )
2025 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
2026 n_cell,
"CellToOutputWeights");
2030 bool peephole_weights_all_or_none =
2031 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
2032 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
2033 || ( !m_CellToInputWeights && !m_CellToForgetWeights
2034 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
2035 if (!peephole_weights_all_or_none)
2041 if (m_Parameters.m_CifgEnabled)
2043 if (m_InputGateBias)
2050 if (!m_InputGateBias)
2053 "must be present.");
2055 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
2056 n_cell,
"InputGateBias");
2059 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2060 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
2062 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2063 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
2065 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2066 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
2068 if (m_ProjectionWeights)
2070 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
2071 (n_cell * n_output),
"ProjectionWeights");
2073 if (m_ProjectionBias)
2075 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
2082 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2083 !m_Parameters.m_ProjectionEnabled)
2084 || (m_ProjectionWeights && !m_ProjectionBias &&
2085 m_Parameters.m_ProjectionEnabled)
2086 || (m_ProjectionWeights && m_ProjectionBias &&
2087 m_Parameters.m_ProjectionEnabled));
2088 if (!projecton_tensors_consistent)
2097 if (m_InputLayerNormWeights)
2099 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2101 if (m_ForgetLayerNormWeights)
2103 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2105 if (m_CellLayerNormWeights)
2107 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2109 if (m_OutputLayerNormWeights)
2111 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2114 if (m_Parameters.m_LayerNormEnabled)
2116 if (!m_Parameters.m_CifgEnabled)
2118 if (!m_InputLayerNormWeights)
2121 "disabled but InputLayerNormWeights are not present");
2123 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2124 1, n_cell,
"InputLayerNormWeights");
2126 else if (m_InputLayerNormWeights)
2132 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2133 "ForgetLayerNormWeights");
2134 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2136 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2137 "OutputLayerNormWeights");
2138 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2140 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2141 "CellLayerNormWeights");
2142 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2144 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2147 "normalisation weights are present.");
2153 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2155 ValidateNumInputs(workloadInfo, descriptorName, 1);
2156 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2171 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2176 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2178 ValidateNumInputs(workloadInfo, descriptorName, 1);
2179 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2194 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2199 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2201 ValidateNumInputs(workloadInfo, descriptorName, 1);
2202 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2217 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2222 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2224 ValidateNumInputs(workloadInfo, descriptorName, 1);
2225 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2240 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2245 const std::string descriptorName{
"DivisionQueueDescriptor"};
2247 ValidateNumInputs(workloadInfo, descriptorName, 2);
2248 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2254 std::vector<DataType> supportedTypes =
2265 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2266 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2267 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2269 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2279 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2281 ValidateNumInputs(workloadInfo, descriptorName, 2);
2282 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2288 std::vector<DataType> supportedTypes =
2299 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2300 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2301 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2303 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2313 const std::string descriptorName{
"MaximumQueueDescriptor"};
2315 ValidateNumInputs(workloadInfo, descriptorName, 2);
2316 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2322 std::vector<DataType> supportedTypes =
2333 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2334 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2335 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2337 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2347 const std::string descriptorName{
"MeanQueueDescriptor"};
2349 ValidateNumInputs(workloadInfo, descriptorName, 1);
2350 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2355 std::vector<DataType> supportedTypes =
2367 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2368 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2370 if (m_Parameters.m_KeepDims)
2372 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2374 else if (m_Parameters.m_Axis.empty())
2376 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2380 unsigned int outputDim =
2382 ValidateTensorNumDimensions(outputTensorInfo,
2384 outputDim > 0 ? outputDim : 1,
2391 const std::string descriptorName{
"PadQueueDescriptor"};
2393 ValidateNumInputs(workloadInfo, descriptorName, 1);
2394 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2400 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2405 "as there are dimensions in the input tensor that is " +
2407 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2413 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2415 ValidateNumInputs(workloadInfo, descriptorName, 1);
2416 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2421 std::vector<DataType> supportedTypes =
2432 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2442 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2444 ValidateNumInputs(workloadInfo, descriptorName, 1);
2445 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2450 std::vector<DataType> supportedTypes =
2460 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2461 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2466 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2468 ValidateNumInputs(workloadInfo, descriptorName, 1);
2469 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2474 std::vector<DataType> supportedTypes =
2484 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2485 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2487 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2496 if (m_Parameters.m_Begin.size() != rank)
2501 if (m_Parameters.m_End.size() != rank)
2506 if (m_Parameters.m_Stride.size() != rank)
2512 for (
auto& stride : m_Parameters.m_Stride)
2523 const std::string descriptorName{
"MinimumQueueDescriptor"};
2525 ValidateNumInputs(workloadInfo, descriptorName, 2);
2526 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2532 std::vector<DataType> supportedTypes =
2543 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2544 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2545 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2547 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2557 const std::string descriptorName{
"DebugQueueDescriptor"};
2559 ValidateNumInputs(workloadInfo, descriptorName, 1);
2560 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2565 const std::string descriptorName{
"EqualQueueDescriptor"};
2567 ValidateNumInputs(workloadInfo, descriptorName, 2);
2568 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2574 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2589 const std::string descriptorName{
"GreaterQueueDescriptor"};
2591 ValidateNumInputs(workloadInfo, descriptorName, 2);
2592 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2598 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2613 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2615 ValidateNumInputs(workloadInfo, descriptorName, 1);
2616 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2621 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2623 std::vector<DataType> supportedTypes =
2633 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2634 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2639 const std::string descriptorName{
"GatherQueueDescriptor"};
2641 ValidateNumInputs(workloadInfo, descriptorName, 2);
2642 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2653 std::vector<DataType> supportedTypes =
2664 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2666 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2669 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2674 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2676 ValidateNumInputs(workloadInfo, descriptorName, 2);
2684 if (m_Anchors ==
nullptr)
2691 const TensorInfo& anchorsInfo = m_Anchors->GetTensorInfo();
2698 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2699 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2700 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2702 const std::vector<DataType> supportedInputTypes =
2712 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2713 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2714 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2716 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2717 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2718 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2719 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2722 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2723 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2724 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2725 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2727 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2730 "must be positive and less than or equal to 1.");
2733 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2736 "should be equal to number of classes + 1.");
2742 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2744 ValidateNumInputs(workloadInfo, descriptorName, 1);
2745 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2755 std::vector<DataType> supportedTypes =
2762 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2767 const std::string& descriptorName{
"MergeQueueDescriptor"};
2769 ValidateNumInputs(workloadInfo, descriptorName, 2);
2770 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2776 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2777 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2779 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2780 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2785 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2787 ValidateNumInputs(workloadInfo, descriptorName, 1);
2788 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2793 std::vector<DataType> supportedTypes =
2806 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2807 ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName);
2812 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2814 ValidateNumInputs(workloadInfo, descriptorName, 2);
2815 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2823 std::vector<DataType> supportedTypes =
2832 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2833 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2835 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2836 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2838 ValidateTensorShapesMatch(inputTensorInfo0,
2844 ValidateTensorShapesMatch(inputTensorInfo0,
2858 const std::string& descriptorName{
"PreluQueueDescriptor"};
2860 ValidateNumInputs(workloadInfo, descriptorName, 2);
2861 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2867 std::vector<DataType> supportedTypes
2877 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2878 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2880 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2882 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2883 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2885 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2895 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2897 ValidateNumInputs(workloadInfo, descriptorName, 1);
2898 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2903 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2904 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2906 ValidatePointer(m_Weight, descriptorName,
"weight");
2908 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2909 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2911 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2914 if (m_Parameters.m_BiasEnabled)
2916 ValidatePointer(m_Bias, descriptorName,
"bias");
2918 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
2922 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2925 ValidatePerAxisQuantization(inputTensorInfo,
2928 optionalBiasTensorInfo,
2931 std::vector<DataType> supportedTypes =
2941 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2942 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2947 const std::string descriptorName{
"TransposeQueueDescriptor"};
2949 ValidateNumInputs(workloadInfo, descriptorName, 1);
2950 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2957 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
2958 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
2960 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
2962 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
2965 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
2966 "must match dst dimension " + to_string(i) +
2967 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
2971 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2976 const std::string descriptorName{
"QLstmQueueDescriptor"};
2979 ValidateNumInputs(workloadInfo, descriptorName, 3);
2980 ValidateNumOutputs(workloadInfo, descriptorName, 3);
2992 std::vector<DataType> inputOutputSupportedTypes =
2997 std::vector<DataType> cellStateSupportedTypes =
3002 std::vector<DataType> weightsSupportedTypes =
3007 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3012 std::vector<DataType> biasSupportedTypes =
3018 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3019 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3020 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3022 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3023 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3024 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3027 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3028 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3029 "outputStateIn",
"outputStateOut");
3030 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3033 const uint32_t numBatches = inputInfo.GetShape()[0];
3034 const uint32_t inputSize = inputInfo.GetShape()[1];
3035 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3036 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3039 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3040 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3041 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
3043 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3044 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
3045 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
3048 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3049 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3050 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
3052 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3053 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3054 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
3056 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3057 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3058 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
3060 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3061 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3062 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
3063 " RecurrentToForgetWeights");
3065 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3066 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3067 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3069 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3070 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3071 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3074 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3076 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3077 "inputToForgetWeights",
"inputToCellWeights");
3078 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3079 "inputToForgetWeights",
"inputToOutputWeights");
3081 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3082 "inputToForgetWeights",
"recurrentToForgeteights");
3083 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3084 "inputToForgetWeights",
"recurrentToCellWeights");
3085 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3086 "inputToForgetWeights",
"recurrentToOutputWeights");
3089 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3090 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3091 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
3093 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3094 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3095 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
3097 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3098 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3099 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
3102 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3104 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3105 "forgetGateBias",
"cellBias");
3106 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3107 "forgetGateBias",
"outputGateBias");
3110 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3111 !m_Parameters.m_CifgEnabled) ||
3112 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3113 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3115 if (!allCifgParamsPresentOrNot)
3118 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3119 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3120 "set appropriately.");
3123 if (!m_Parameters.m_CifgEnabled)
3126 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3127 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3129 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3130 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3131 " RecurrentToInputWeights");
3133 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3134 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3137 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3138 "inputToForgetWeights",
"inputToInputWeights");
3139 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3140 "inputToForgetWeights",
"recurrentToInputWeights");
3141 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3142 "forgetGateBias",
"inputGateBias");
3146 bool allPeepholeWeightsPresentOrNot =
3147 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3148 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3149 || (!m_CellToInputWeights && !m_CellToForgetWeights
3150 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3152 if (!allPeepholeWeightsPresentOrNot)
3155 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3156 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3157 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3161 if (m_Parameters.m_PeepholeEnabled)
3163 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3164 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3165 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3167 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3168 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3169 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3170 "cellToForgetWeight",
"cellToOutputWeights");
3172 if (!m_Parameters.m_CifgEnabled)
3174 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3175 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3176 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3177 "cellToForgetWeights",
"cellToInputWeights");
3182 bool allLayerNormWeightsPresentOrNot =
3183 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3184 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3185 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3186 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3188 if (!allLayerNormWeightsPresentOrNot)
3191 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3192 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3193 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3194 "only be present when Layer Norm is enabled and CIFG is disabled. " 3195 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3198 if (m_Parameters.m_LayerNormEnabled)
3200 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3201 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3202 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3204 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3205 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3206 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3207 "forgetLayerNormWeights",
"cellLayerNormWeights");
3209 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3210 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3211 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3212 "forgetLayerNormWeights",
"outputLayerNormWeights");
3214 if (!m_Parameters.m_CifgEnabled)
3216 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3217 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3218 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3219 "forgetLayerNormWeights",
"inputLayerNormWeights");
3224 bool correctProjectionTensorsPresent =
3225 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3226 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3227 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3229 if (!correctProjectionTensorsPresent)
3232 ": If projection is enabled, ProjectionWeights should be present and " 3233 "ProjectionBias is optional. If projection is disabled, neither " 3234 "ProjectionWeights nor ProjectionBias should be present.");
3237 if (m_Parameters.m_ProjectionEnabled)
3239 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3240 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3241 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3243 if (m_ProjectionBias)
3245 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3246 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3247 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3251 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3252 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3254 ": If projection is disabled, output quantization info (scale, offset) " 3255 "should match HiddenStateScale and HiddenStateZeroPoint.");
3262 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3265 ValidateNumInputs(workloadInfo, descriptorName, 3);
3266 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3276 std::vector<DataType> inputOutputSupportedTypes =
3281 std::vector<DataType> cellStateSupportedTypes =
3286 std::vector<DataType> weightsSupportedTypes =
3291 std::vector<DataType> biasSupportedTypes =
3297 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3298 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3299 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3301 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3302 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3305 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3306 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3307 "outputStateIn",
"outputStateOut");
3308 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3311 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3312 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3313 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3316 const uint32_t numBatches = inputInfo.GetShape()[0];
3317 const uint32_t inputSize = inputInfo.GetShape()[1];
3318 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3321 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3322 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3323 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3324 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3325 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3328 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3329 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3330 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3332 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3333 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3334 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3336 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3337 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3338 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3340 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3341 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3342 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3344 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3345 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3346 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3348 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3349 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3350 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3351 " RecurrentToForgetWeights");
3353 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3354 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3355 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3357 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3358 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3359 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3362 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3364 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3365 "inputToInputWeights",
"inputToForgetWeights");
3366 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3367 "inputToInputWeights",
"inputToCellWeights");
3368 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3369 "inputToInputWeights",
"inputToOutputWeights");
3371 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3372 "inputToInputWeights",
"recurrentToInputWeights");
3373 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3374 "inputToInputWeights",
"recurrentToForgeteights");
3375 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3376 "inputToInputWeights",
"recurrentToCellWeights");
3377 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3378 "inputToInputWeights",
"recurrentToOutputWeights");
3381 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3382 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3383 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3384 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3385 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3386 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3388 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3389 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3390 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3391 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3392 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3393 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3394 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3395 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3398 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3399 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3400 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3402 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3403 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3404 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3406 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3407 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3408 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3410 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3411 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3412 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3415 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3417 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3418 "inputGateBias",
"forgetGateBias");
3419 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3420 "inputGateBias",
"cellBias");
3421 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3422 "inputGateBias",
"outputGateBias");
3425 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3426 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3427 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3428 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3433 const std::string descriptorName{
"AbsQueueDescriptor"};
3435 ValidateNumInputs(workloadInfo, descriptorName, 1);
3436 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3441 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3443 std::vector<DataType> supportedTypes =
3454 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3455 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3460 const std::string descriptorName{
"SliceQueueDescriptor"};
3462 ValidateNumInputs(workloadInfo, descriptorName, 1);
3463 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3468 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3476 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3479 if (m_Parameters.m_Begin.size() != rank)
3482 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3484 if (m_Parameters.m_Size.size() != rank)
3487 ": Length of size descriptor must equal rank " + std::to_string(rank));
3492 for (
unsigned int i = 0u; i < rank; ++i)
3494 if (m_Parameters.m_Size[i] != outputShape[i])
3503 for(
unsigned int i = 0u; i < rank; ++i)
3505 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3508 std::to_string(i) +
" exceeds input size.");
3515 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3517 ValidateNumInputs(workloadInfo, descriptorName, 1);
3518 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3523 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3524 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3526 std::vector<DataType> supportedTypes =
3536 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3537 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3539 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3541 if (m_Parameters.m_BlockSize == 0)
3547 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3552 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3555 "must be divisible by block size.");
3559 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3562 "must be divisible by the square of block size." );
3568 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3570 ValidateNumInputs(workloadInfo, descriptorName, 2);
3571 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3577 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3592 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3594 ValidateNumInputs(workloadInfo, descriptorName, 1);
3595 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3600 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3602 std::vector<DataType> supportedTypes =
3613 std::vector<DataType> logicalSupportedTypes =
3620 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3624 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3628 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3633 const std::string descriptorName{
"RankQueueDescriptor"};
3635 ValidateNumInputs(workloadInfo, descriptorName, 1);
3636 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3641 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
3642 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3644 std::vector<DataType> supportedTypes =
3656 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3657 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3662 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3664 ValidateNumInputs(workloadInfo, descriptorName, 2);
3665 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3671 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3696 const std::string descriptorName{
"ReduceQueueDescriptor"};
3698 ValidateNumInputs(workloadInfo, descriptorName, 1);
3699 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3704 std::vector<DataType> supportedTypes =
3715 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3716 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3723 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3735 std::vector<DataType> supportedTypes =
3741 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3750 "input_" + std::to_string(i));
3757 "LstmQueueDescriptor",
3759 "output_" + std::to_string(i));
3765 if (m_Parameters.m_ClippingThresCell < 0.0f)
3769 if (m_Parameters.m_ClippingThresProj < 0.0f)
3774 unsigned int batchIndx = 0;
3775 unsigned int inputIndx = 1;
3776 uint32_t timeStep = 1;
3777 unsigned int timeIndx = 1;
3779 if (m_Parameters.m_TimeMajor)
3790 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
3791 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
3792 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
3793 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
3796 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 3, (timeStep * n_batch * n_input),
3797 descriptorName +
" input_0");
3799 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
3800 descriptorName +
" input_1");
3802 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
3803 descriptorName +
" input_2");
3806 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 3, (timeStep * n_batch * n_output),
3807 descriptorName +
" output_0");
3810 if ( m_InputToInputWeights )
3812 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
3813 (n_cell * n_input),
"InputLayerNormWeights");
3816 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
3817 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
3818 (n_cell * n_input),
"InputToForgetWeights");
3820 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
3821 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
3822 (n_cell * n_input),
"InputToCellWeights");
3824 if ( m_RecurrentToInputWeights )
3826 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
3827 (n_cell * n_output),
"RecurrentToInputWeights");
3830 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
3831 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
3832 (n_cell * n_output),
"RecurrentToForgetWeights");
3834 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
3835 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
3836 (n_cell * n_output),
"RecurrentToCellWeights");
3840 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
3841 !m_Parameters.m_CifgEnabled) ||
3842 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3843 m_Parameters.m_CifgEnabled));
3844 if (!cifg_weights_all_or_none)
3847 "RecurrentToInputWeights must either both be present (regular LSTM) " 3848 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 3852 if ( m_CellToInputWeights )
3854 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
3855 n_cell,
"CellToInputWeights");
3857 if ( m_CellToForgetWeights )
3859 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
3860 n_cell,
"CellToForgetWeights");
3862 if ( m_CellToOutputWeights )
3864 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
3865 n_cell,
"CellToOutputWeights");
3869 bool peephole_weights_all_or_none =
3870 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3871 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3872 || ( !m_CellToInputWeights && !m_CellToForgetWeights
3873 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3874 if (!peephole_weights_all_or_none)
3880 if (m_Parameters.m_CifgEnabled)
3882 if (m_InputGateBias)
3889 if (!m_InputGateBias)
3892 "must be present.");
3894 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
3895 n_cell,
"InputGateBias");
3898 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
3899 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
3901 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
3902 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
3904 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
3905 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
3907 if (m_ProjectionWeights)
3909 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
3910 (n_cell * n_output),
"ProjectionWeights");
3912 if (m_ProjectionBias)
3914 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
3921 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
3922 !m_Parameters.m_ProjectionEnabled)
3923 || (m_ProjectionWeights && !m_ProjectionBias &&
3924 m_Parameters.m_ProjectionEnabled)
3925 || (m_ProjectionWeights && m_ProjectionBias &&
3926 m_Parameters.m_ProjectionEnabled));
3927 if (!projecton_tensors_consistent)
3936 if (m_InputLayerNormWeights)
3938 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
3940 if (m_ForgetLayerNormWeights)
3942 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
3944 if (m_CellLayerNormWeights)
3946 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
3948 if (m_OutputLayerNormWeights)
3950 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
3953 if (m_Parameters.m_LayerNormEnabled)
3955 if (!m_Parameters.m_CifgEnabled)
3957 if (!m_InputLayerNormWeights)
3960 "disabled but InputLayerNormWeights are not present");
3962 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
3963 1, n_cell,
"InputLayerNormWeights");
3965 else if (m_InputLayerNormWeights)
3971 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
3972 "ForgetLayerNormWeights");
3973 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
3975 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
3976 "OutputLayerNormWeights");
3977 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
3979 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
3980 "CellLayerNormWeights");
3981 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
3983 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
3986 "normalisation weights are present.");
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool HasPerAxisQuantization() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
Optional< unsigned int > GetQuantizationDim() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_LOG(severity)
void ValidateInputsOutputs(const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const
Copyright (c) 2021 ARM Limited and Contributors.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< float > GetQuantizationScales() const
bool HasMultipleQuantizationScales() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetHeightIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
constexpr const char * GetDataTypeName(DataType dataType)
constexpr bool IsQuantized8BitType(DataType dataType)
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_InputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_NO_DEPRECATE_WARN_END
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_ASSERT_MSG(COND, MSG)
void Validate(const WorkloadInfo &workloadInfo) const
int32_t GetQuantizationOffset() const
float GetQuantizationScale() const
Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout...
DataType GetDataType() const
bool has_value() const noexcept
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetUnsignedAxis(const unsigned int inputDimension, const int axis)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_OutputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
DataType GetBiasDataType(DataType inputDataType)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< ITensorHandle * > m_Outputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
Function that returns the tensor rank.
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Contains information about TensorInfos of a layer.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< ITensorHandle * > m_Inputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
unsigned int GetChannelsIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumElements() const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< unsigned int > m_Origin