19 #include <fmt/format.h> 29 switch (inputDataType)
31 case DataType::Float16:
32 return DataType::Float16;
34 case DataType::Float32:
35 return DataType::Float32;
36 case DataType::QAsymmS8:
37 return DataType::Signed32;
38 case DataType::QAsymmU8:
39 return DataType::Signed32;
40 case DataType::QSymmS8:
41 return DataType::Signed32;
42 case DataType::QSymmS16:
43 return DataType::Signed32;
46 return DataType::Float32;
56 std::string to_string(T value)
58 std::ostringstream os;
64 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
69 paramName +
" parameter must be set.");
74 void ValidateTensorShapesMatch(
const TensorInfo& first,
76 std::string
const& descName,
77 std::string
const& firstName,
78 std::string
const& secondName)
83 + firstName +
" & " + secondName +
" must have identical shapes");
88 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
93 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
99 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
104 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
110 void ValidateTensorNumDimensions(
const TensorInfo& tensor,
111 std::string
const& descName,
112 unsigned int numDimensions,
113 std::string
const& tensorName)
119 tensorName +
" tensor.");
124 void ValidateTensorNumElements(
const TensorInfo& tensor,
125 std::string
const& descName,
126 unsigned int numElements,
127 std::string
const& tensorName)
133 tensorName +
" tensor.");
138 void ValidateTensorNumDimNumElem(
const TensorInfo& tensorInfo,
139 unsigned int numDimension,
140 unsigned int numElements,
141 std::string
const& tensorName)
143 const std::string functionName{
"ValidateTensorNumDimNumElem"};
144 ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName);
145 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
150 const std::string& descName, std::string
const& tensorName)
159 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
164 ": Expected data type which supports per-axis quantization scheme but got " +
170 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
172 const std::string& descName,
173 std::string
const& firstName,
174 std::string
const& secondName)
186 if (firstDataType != secondDataType)
189 " must be of the same quantized type, " +
197 " must have the same quantization space, " +
206 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
209 const std::string& descName)
212 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 214 constexpr
float tolerance = 0.0001f;
215 if (std::abs(biasScale - expectedScale) > tolerance)
218 ARMNN_LOG(
warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
219 " for bias quantization scale (product of input and weight scales), but got " <<
220 biasScale <<
". Using scale provided.";
236 if (weightScales.size() != biasScales.size())
238 std::stringstream msg;
239 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, " 240 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
241 <<
", biases=" << biasScales.size();
245 for (
size_t i = 0ul; i < biasScales.size(); ++i)
248 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
260 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
261 unsigned int numExpected,
262 const std::string& descName,
263 const std::string& varName)
265 if (vec.empty() && numExpected > 0)
270 for (
unsigned int i = 0; i < numExpected; ++i)
280 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
283 std::string
const& descName,
284 std::string
const& firstName,
285 std::string
const& secondName)
292 + firstName +
" & " + secondName
293 +
" must have the same number of dimensions in order to be broadcasted");
296 std::vector<uint32_t> outputDims(numDims, 0u);
297 for (uint32_t i = 0; i < numDims; i++)
300 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
301 if (dimsNotEqual && dimsNotOne)
307 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
308 if (broadcastShape != output.
GetShape())
311 + firstName +
" & " + secondName
312 +
" does not match the output shape");
318 const std::vector<armnn::DataType>& supportedTypes,
319 std::string
const& descName)
321 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
322 if (iterator == supportedTypes.end())
329 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
331 std::string
const& descName,
332 std::string
const& firstName,
333 std::string
const& secondName)
338 " must have identical data types.");
343 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
345 std::string
const& descName,
346 std::string
const& firstName,
347 std::string
const& secondName)
352 " must have the same number of elements.");
356 void ValidateWeightDataType(
const TensorInfo& inputInfo,
358 const std::string& descName)
363 const std::vector<DataType> validTypes =
370 ValidateDataTypes(weightInfo, validTypes, descName);
374 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
378 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
379 const std::string& descName,
380 const std::string& tensorName)
386 "not set on tensor {1}.", descName, tensorName));
390 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
391 const std::string& descName,
392 const std::string& tensorName)
395 if (quantizationOffset != 0)
398 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
399 descName, tensorName, quantizationOffset));
403 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
407 const std::string& descName)
414 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
416 if (!canHavePerAxisQuantization)
419 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 420 "per-axis quantization.", descName,
"weight"));
424 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
425 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
426 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
434 "{}: Per-axis quantization parameters not set on bias tensor, " 435 "despite being set on weight tensor.", descName));
438 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
439 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
440 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
448 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 450 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
451 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
457 const std::string descriptorName{
"MapQueueDescriptor"};
459 ValidateNumInputs(workloadInfo, descriptorName, 1);
460 ValidateNumOutputs(workloadInfo, descriptorName, 0);
462 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
467 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
475 const std::string descriptorName{
"UnmapQueueDescriptor"};
477 ValidateNumInputs(workloadInfo, descriptorName, 1);
478 ValidateNumOutputs(workloadInfo, descriptorName, 0);
480 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
485 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
493 const std::string descriptorName{
"MemCopyQueueDescriptor"};
495 ValidateNumInputs(workloadInfo, descriptorName, 1);
496 ValidateNumOutputs(workloadInfo, descriptorName , 1);
501 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
502 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
507 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
511 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
516 "{0}: Invalid NULL input {1}.", descriptorName, i));
529 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
530 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
542 "Number of input infos ({0}) does not match the number of output infos ({1})",
552 "Number of elements for tensor input and output {} does not match", i ));
564 "Number of inputs ({0}) does not match the number of outputs ({1})",
568 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
585 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
606 const std::string descriptorName{
"ActivationQueueDescriptor"};
608 ValidateNumInputs(workloadInfo, descriptorName, 1);
609 ValidateNumOutputs(workloadInfo, descriptorName, 1);
614 std::vector<DataType> supportedTypes =
624 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
625 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
626 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
631 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
633 ValidateNumInputs(workloadInfo, descriptorName, 1);
634 ValidateNumOutputs(workloadInfo, descriptorName, 1);
645 std::vector<DataType> supportedInputTypes =
657 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
659 auto inputShape = inputTensorInfo.
GetShape();
660 auto outputShape = outputTensorInfo.
GetShape();
665 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
668 if (inputShape.GetNumDimensions() == 1)
670 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
677 for (
unsigned int i = 0; i < unsignedAxis; ++i)
679 if (outputShape[i] != inputShape[i])
685 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
687 if (outputShape[i - 1] != inputShape[i])
697 const std::string descriptorName{
"CastQueueDescriptor"};
699 ValidateNumInputs(workloadInfo, descriptorName, 1);
700 ValidateNumOutputs(workloadInfo, descriptorName, 1);
705 std::vector<DataType> supportedTypes =
718 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
719 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
724 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
726 ValidateNumInputs(workloadInfo, descriptorName, 1);
727 ValidateNumOutputs(workloadInfo, descriptorName, 1);
732 std::vector<DataType> supportedTypes =
742 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
743 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
744 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
749 const std::string descriptorName{
"SplitterQueueDescriptor"};
751 ValidateNumInputs(workloadInfo, descriptorName, 1);
754 std::vector<DataType> supportedTypes =
770 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
772 const std::string outputName =
"output_" + std::to_string(i);
773 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
784 descriptorName +
": Number of split windows " 785 "has to match number of workloadInfo.m_OutputTensorInfos. " 786 "Number of windows: " +
787 to_string(m_ViewOrigins.size()) +
788 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
793 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
800 "have the same dimensionality as the input tensor. " 801 "Window origin (index: " +
802 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
803 " dimensions, the input " 805 to_string(inputDims) +
" dimensions.");
807 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
813 "be smaller or equal than the size of the input in that coord.");
821 const std::string descriptorName{
"ConcatQueueDescriptor"};
823 ValidateNumOutputs(workloadInfo, descriptorName, 1);
843 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
848 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
856 descriptorName +
": Number of split windows " 857 "has to match number of workloadInfo.m_InputTensorInfos. " 858 "Number of windows: " +
859 to_string(m_ViewOrigins.size()) +
860 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
865 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
869 if (e.
m_Origin.size() != outputDims)
872 "have the same dimensionality as the output tensor. " 873 "Window origin (index: " +
874 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
875 " dimensions, the output " 877 to_string(outputDims) +
" dimensions.");
880 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
886 "be smaller or equal than the size of the output in that coord.");
892 std::vector<DataType> supportedTypes =
908 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
910 const std::string inputName =
"input_" + std::to_string(i);
911 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
917 const std::string descriptorName{
"StackQueueDescriptor"};
919 ValidateNumOutputs(workloadInfo, descriptorName, 1);
927 const TensorShape& inputShape = m_Parameters.m_InputShape;
946 "than the number of input dimensions.");
951 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
953 if (outputShape[i] != inputShape[i])
956 "match shape inferred from input tensor.");
960 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
963 "match shape inferred from input tensor.");
966 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
968 if (outputShape[i] != inputShape[i-1])
971 "match shape inferred from input tensor.");
981 std::vector<DataType> supportedTypes =
993 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1001 "input_" + std::to_string(i));
1013 const std::string descriptorName{
"FillQueueDescriptor"};
1015 ValidateNumInputs(workloadInfo, descriptorName, 1);
1016 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1021 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 1,
"input");
1023 std::vector<DataType> supportedTypes =
1031 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1036 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1038 uint32_t numInputs = 2;
1039 if (m_Parameters.m_BiasEnabled)
1044 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1045 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1050 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1058 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 2,
"weight");
1060 if (m_Parameters.m_BiasEnabled)
1064 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1066 ValidateTensorNumDimensions(biasTensorInfo, descriptorName, 1,
"bias");
1070 std::vector<DataType> supportedTypes =
1080 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1088 "for BFloat16 input.");
1093 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1099 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1101 ValidateNumInputs(workloadInfo, descriptorName, 1);
1102 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1108 std::vector<DataType> supportedTypes =
1118 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1120 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1122 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1127 const std::string descriptorName{
"AdditionQueueDescriptor"};
1129 ValidateNumInputs(workloadInfo, descriptorName, 2);
1130 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1136 std::vector<DataType> supportedTypes =
1147 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1148 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1149 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1151 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1152 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1154 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1164 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1166 ValidateNumInputs(workloadInfo, descriptorName, 2);
1167 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1173 std::vector<DataType> supportedTypes =
1184 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1185 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1186 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1188 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1189 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1191 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1201 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1203 ValidateNumInputs(workloadInfo, descriptorName, 1);
1204 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1209 std::vector<DataType> supportedTypes =
1219 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1220 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1222 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1223 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1225 ValidatePointer(m_Mean, descriptorName,
"mean");
1226 ValidatePointer(m_Variance, descriptorName,
"variance");
1227 ValidatePointer(m_Beta, descriptorName,
"beta");
1228 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1230 const TensorInfo& mean = m_Mean->GetTensorInfo();
1231 const TensorInfo& variance = m_Variance->GetTensorInfo();
1232 const TensorInfo& beta = m_Beta->GetTensorInfo();
1233 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1235 ValidateTensorNumDimensions(mean, descriptorName, 1,
"mean");
1236 ValidateTensorNumDimensions(variance, descriptorName, 1,
"variance");
1237 ValidateTensorNumDimensions(beta, descriptorName, 1,
"beta");
1238 ValidateTensorNumDimensions(gamma, descriptorName, 1,
"gamma");
1240 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1241 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1242 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1247 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1249 ValidateNumInputs(workloadInfo, descriptorName, 1);
1250 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1255 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1256 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1258 ValidatePointer(m_Weight, descriptorName,
"weight");
1260 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1261 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1263 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1266 if (m_Parameters.m_BiasEnabled)
1268 ValidatePointer(m_Bias, descriptorName,
"bias");
1270 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1274 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1277 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1280 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1281 "cannot be either negative or 0.",
1282 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1285 ValidatePerAxisQuantization(inputTensorInfo,
1288 optionalBiasTensorInfo,
1291 std::vector<DataType> supportedTypes =
1302 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1310 "for BFloat16 input.");
1315 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1321 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1323 uint32_t numInputs = 2;
1324 if (m_Parameters.m_BiasEnabled)
1328 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1329 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1334 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 5,
"input");
1335 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 5,
"output");
1338 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 5,
"weight");
1340 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1343 if (m_Parameters.m_BiasEnabled)
1345 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1349 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1352 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 || m_Parameters.m_StrideZ <= 0 )
1355 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})" 1356 "cannot be either negative or 0.",
1357 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY, m_Parameters.m_StrideZ));
1360 ValidatePerAxisQuantization(inputTensorInfo,
1363 optionalBiasTensorInfo,
1366 std::vector<DataType> supportedTypes =
1377 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1378 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1383 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1385 ValidateNumInputs(workloadInfo, descriptorName, 1);
1386 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1391 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1392 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1394 ValidatePointer(m_Weight, descriptorName,
"weight");
1396 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1397 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1399 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1402 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) " 1403 "cannot be smaller than 1.",
1404 descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
1407 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1410 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1411 "cannot be either negative or 0.",
1412 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1415 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1419 const unsigned int numWeightOutputChannels = weightTensorInfo.
GetShape()[3];
1420 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1421 if (numWeightOutputChannels != numOutputChannels)
1424 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]." 1425 "But 4th dimension is not equal to Cout. Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1433 if (weightTensorInfo.
GetShape()[0] != 1)
1436 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]." 1437 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1445 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1448 if (m_Parameters.m_BiasEnabled)
1450 ValidatePointer(m_Bias, descriptorName,
"bias");
1452 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1455 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1458 ValidatePerAxisQuantization(inputTensorInfo,
1461 optionalBiasTensorInfo,
1464 std::vector<DataType> supportedTypes =
1474 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1475 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1480 const std::string descriptorName{
"PermuteQueueDescriptor"};
1482 ValidateNumInputs(workloadInfo, descriptorName, 1);
1483 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1490 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
1491 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
1493 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1495 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1498 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1499 "must match dst dimension " + to_string(mapping[i]) +
1500 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1504 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1509 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1511 ValidateNumInputs(workloadInfo, descriptorName, 1);
1512 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1517 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1518 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1520 std::vector<DataType> supportedTypes =
1530 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1531 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1536 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1538 ValidateNumInputs(workloadInfo, descriptorName, 1);
1539 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1544 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 5,
"input");
1545 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 5,
"output");
1547 std::vector<DataType> supportedTypes =
1557 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1558 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1562 void ResizeBilinearQueueDescriptor::Validate(
const WorkloadInfo& workloadInfo)
const 1564 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1566 ValidateNumInputs(workloadInfo, descriptorName, 1);
1567 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1572 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1573 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1575 std::vector<DataType> supportedTypes =
1585 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1586 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1589 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1590 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1591 if (inputBatchSize != outputBatchSize)
1594 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1595 descriptorName, inputBatchSize, outputBatchSize));
1601 if (inputChannelCount != outputChannelCount)
1604 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1605 descriptorName, inputChannelCount, outputChannelCount));
1611 const std::string descriptorName{
"ResizeQueueDescriptor"};
1613 ValidateNumInputs(workloadInfo, descriptorName, 1);
1614 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1619 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1620 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1622 std::vector<DataType> supportedTypes =
1632 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1633 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1636 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1637 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1638 if (inputBatchSize != outputBatchSize)
1641 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1642 descriptorName, inputBatchSize, outputBatchSize));
1648 if (inputChannelCount != outputChannelCount)
1651 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1652 descriptorName, inputChannelCount, outputChannelCount));
1658 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1660 ValidateNumInputs(workloadInfo, descriptorName, 1);
1661 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1666 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1667 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1669 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1671 if (m_Parameters.m_Min > m_Parameters.m_Max)
1679 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1681 ValidateNumInputs(workloadInfo, descriptorName, 1);
1682 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1692 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1695 std::vector<DataType> supportedTypes =
1702 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1703 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1708 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1710 ValidateNumInputs(workloadInfo, descriptorName, 1);
1711 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1721 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1724 std::vector<DataType> supportedTypes =
1734 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1735 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1740 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1742 ValidateNumInputs(workloadInfo, descriptorName, 1);
1743 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1748 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1750 std::vector<DataType> supportedTypes =
1757 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1758 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1763 const std::string descriptorName{
"ConstantQueueDescriptor"};
1765 ValidateNumInputs(workloadInfo, descriptorName, 0);
1766 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1774 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1777 std::vector<DataType> supportedTypes =
1789 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1794 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1796 ValidateNumInputs(workloadInfo, descriptorName, 1);
1797 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1802 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1805 std::vector<DataType> supportedTypes =
1817 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1818 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1823 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1825 ValidateNumInputs(workloadInfo, descriptorName, 1);
1826 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1831 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1832 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1834 if (m_Parameters.m_BlockShape.size() != 2)
1839 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1842 "dimensions as Block Shape.");
1847 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1848 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1852 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1853 widthPad.first + widthPad.second;
1854 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1855 heightPad.first + heightPad.second;
1857 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1859 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1861 if (numOutputElements != numInputElements)
1864 to_string(numInputElements) +
" after padding but output tensor has " +
1865 to_string(numOutputElements) +
" elements.");
1868 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1871 "divisible by Block Shape in all spatial dimensions");
1874 std::vector<DataType> supportedTypes =
1884 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1885 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1890 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1892 ValidateNumInputs(workloadInfo, descriptorName, 1);
1893 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1898 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1899 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1901 std::vector<DataType> supportedTypes =
1911 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1912 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1914 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1916 if (m_Parameters.m_BlockSize == 0)
1922 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1927 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1930 "by block size in all spatial dimensions");
1934 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1937 "must be divisible by the square of block size." );
1943 const std::string descriptorName{
"FloorQueueDescriptor"};
1945 ValidateNumInputs(workloadInfo, descriptorName, 1);
1946 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1951 std::vector<DataType> supportedTypes =
1959 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1960 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1961 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1962 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1969 const std::string descriptorName{
"LstmQueueDescriptor"};
1981 std::vector<DataType> supportedTypes =
1990 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1999 "input_" + std::to_string(i));
2006 "LstmQueueDescriptor",
2008 "output_" + std::to_string(i));
2014 if (m_Parameters.m_ClippingThresCell < 0.0f)
2018 if (m_Parameters.m_ClippingThresProj < 0.0f)
2026 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
2027 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
2028 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
2029 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
2032 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
2033 descriptorName +
" input_0");
2035 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
2036 descriptorName +
" input_1");
2038 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
2039 descriptorName +
" input_2");
2041 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
2042 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
2043 descriptorName +
" output_0");
2046 descriptorName +
" output_1");
2049 descriptorName +
" output_2");
2052 descriptorName +
" output_3");
2055 if ( m_InputToInputWeights )
2057 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
2058 (n_cell * n_input),
"InputLayerNormWeights");
2061 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
2062 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
2063 (n_cell * n_input),
"InputToForgetWeights");
2065 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
2066 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
2067 (n_cell * n_input),
"InputToCellWeights");
2069 if ( m_RecurrentToInputWeights )
2071 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
2072 (n_cell * n_output),
"RecurrentToInputWeights");
2075 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
2076 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
2077 (n_cell * n_output),
"RecurrentToForgetWeights");
2079 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
2080 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
2081 (n_cell * n_output),
"RecurrentToCellWeights");
2085 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
2086 !m_Parameters.m_CifgEnabled) ||
2087 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
2088 m_Parameters.m_CifgEnabled));
2089 if (!cifg_weights_all_or_none)
2092 "RecurrentToInputWeights must either both be present (regular LSTM) " 2093 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 2097 if ( m_CellToInputWeights )
2099 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
2100 n_cell,
"CellToInputWeights");
2102 if ( m_CellToForgetWeights )
2104 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
2105 n_cell,
"CellToForgetWeights");
2107 if ( m_CellToOutputWeights )
2109 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
2110 n_cell,
"CellToOutputWeights");
2114 bool peephole_weights_all_or_none =
2115 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
2116 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
2117 || ( !m_CellToInputWeights && !m_CellToForgetWeights
2118 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
2119 if (!peephole_weights_all_or_none)
2125 if (m_Parameters.m_CifgEnabled)
2127 if (m_InputGateBias)
2134 if (!m_InputGateBias)
2137 "must be present.");
2139 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
2140 n_cell,
"InputGateBias");
2143 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2144 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
2146 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2147 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
2149 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2150 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
2152 if (m_ProjectionWeights)
2154 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
2155 (n_cell * n_output),
"ProjectionWeights");
2157 if (m_ProjectionBias)
2159 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
2166 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2167 !m_Parameters.m_ProjectionEnabled)
2168 || (m_ProjectionWeights && !m_ProjectionBias &&
2169 m_Parameters.m_ProjectionEnabled)
2170 || (m_ProjectionWeights && m_ProjectionBias &&
2171 m_Parameters.m_ProjectionEnabled));
2172 if (!projecton_tensors_consistent)
2181 if (m_InputLayerNormWeights)
2183 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2185 if (m_ForgetLayerNormWeights)
2187 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2189 if (m_CellLayerNormWeights)
2191 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2193 if (m_OutputLayerNormWeights)
2195 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2198 if (m_Parameters.m_LayerNormEnabled)
2200 if (!m_Parameters.m_CifgEnabled)
2202 if (!m_InputLayerNormWeights)
2205 "disabled but InputLayerNormWeights are not present");
2207 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2208 1, n_cell,
"InputLayerNormWeights");
2210 else if (m_InputLayerNormWeights)
2216 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2217 "ForgetLayerNormWeights");
2218 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2220 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2221 "OutputLayerNormWeights");
2222 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2224 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2225 "CellLayerNormWeights");
2226 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2228 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2231 "normalisation weights are present.");
2237 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2239 ValidateNumInputs(workloadInfo, descriptorName, 1);
2240 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2255 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2260 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2262 ValidateNumInputs(workloadInfo, descriptorName, 1);
2263 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2278 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2283 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2285 ValidateNumInputs(workloadInfo, descriptorName, 1);
2286 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2301 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2306 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2308 ValidateNumInputs(workloadInfo, descriptorName, 1);
2309 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2324 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2329 const std::string descriptorName{
"DivisionQueueDescriptor"};
2331 ValidateNumInputs(workloadInfo, descriptorName, 2);
2332 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2338 std::vector<DataType> supportedTypes =
2349 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2350 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2351 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2353 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2363 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2365 ValidateNumInputs(workloadInfo, descriptorName, 2);
2366 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2372 std::vector<DataType> supportedTypes =
2383 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2384 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2385 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2387 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2397 const std::string descriptorName{
"MaximumQueueDescriptor"};
2399 ValidateNumInputs(workloadInfo, descriptorName, 2);
2400 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2406 std::vector<DataType> supportedTypes =
2417 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2418 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2419 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2421 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2431 const std::string descriptorName{
"MeanQueueDescriptor"};
2433 ValidateNumInputs(workloadInfo, descriptorName, 1);
2434 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2439 std::vector<DataType> supportedTypes =
2451 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2452 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2454 if (m_Parameters.m_KeepDims)
2456 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2458 else if (m_Parameters.m_Axis.empty())
2460 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2464 unsigned int outputDim =
2466 ValidateTensorNumDimensions(outputTensorInfo,
2468 outputDim > 0 ? outputDim : 1,
2475 const std::string descriptorName{
"PadQueueDescriptor"};
2477 ValidateNumInputs(workloadInfo, descriptorName, 1);
2478 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2484 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2489 "as there are dimensions in the input tensor that is " +
2491 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2497 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2499 ValidateNumInputs(workloadInfo, descriptorName, 1);
2500 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2505 std::vector<DataType> supportedTypes =
2516 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2526 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2528 ValidateNumInputs(workloadInfo, descriptorName, 1);
2529 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2534 std::vector<DataType> supportedTypes =
2544 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2545 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2550 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2552 ValidateNumInputs(workloadInfo, descriptorName, 1);
2553 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2558 std::vector<DataType> supportedTypes =
2568 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2569 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2571 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2580 if (m_Parameters.m_Begin.size() != rank)
2585 if (m_Parameters.m_End.size() != rank)
2590 if (m_Parameters.m_Stride.size() != rank)
2596 for (
auto& stride : m_Parameters.m_Stride)
2607 const std::string descriptorName{
"MinimumQueueDescriptor"};
2609 ValidateNumInputs(workloadInfo, descriptorName, 2);
2610 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2616 std::vector<DataType> supportedTypes =
2627 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2628 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2629 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2631 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2641 const std::string descriptorName{
"DebugQueueDescriptor"};
2643 ValidateNumInputs(workloadInfo, descriptorName, 1);
2644 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2649 const std::string descriptorName{
"EqualQueueDescriptor"};
2651 ValidateNumInputs(workloadInfo, descriptorName, 2);
2652 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2658 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2673 const std::string descriptorName{
"GreaterQueueDescriptor"};
2675 ValidateNumInputs(workloadInfo, descriptorName, 2);
2676 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2682 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2697 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2699 ValidateNumInputs(workloadInfo, descriptorName, 1);
2700 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2705 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2707 std::vector<DataType> supportedTypes =
2717 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2718 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2723 const std::string descriptorName{
"GatherQueueDescriptor"};
2725 ValidateNumInputs(workloadInfo, descriptorName, 2);
2726 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2737 std::vector<DataType> supportedTypes =
2748 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2750 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2753 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2758 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2760 ValidateNumInputs(workloadInfo, descriptorName, 2);
2768 if (m_Anchors ==
nullptr)
2775 const TensorInfo& anchorsInfo = m_Anchors->GetTensorInfo();
2782 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2783 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2784 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2786 const std::vector<DataType> supportedInputTypes =
2796 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2797 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2798 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2800 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2801 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2802 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2803 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2806 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2807 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2808 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2809 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2811 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2814 "must be positive and less than or equal to 1.");
2817 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2820 "should be equal to number of classes + 1.");
2826 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2828 ValidateNumInputs(workloadInfo, descriptorName, 1);
2829 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2839 std::vector<DataType> supportedTypes =
2846 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2851 const std::string& descriptorName{
"MergeQueueDescriptor"};
2853 ValidateNumInputs(workloadInfo, descriptorName, 2);
2854 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2860 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2861 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2863 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2864 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2869 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2871 ValidateNumInputs(workloadInfo, descriptorName, 1);
2872 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2877 std::vector<DataType> supportedTypes =
2890 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2891 ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName);
2896 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2898 ValidateNumInputs(workloadInfo, descriptorName, 2);
2899 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2907 std::vector<DataType> supportedTypes =
2916 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2917 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2919 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2920 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2922 ValidateTensorShapesMatch(inputTensorInfo0,
2928 ValidateTensorShapesMatch(inputTensorInfo0,
2942 const std::string& descriptorName{
"PreluQueueDescriptor"};
2944 ValidateNumInputs(workloadInfo, descriptorName, 2);
2945 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2951 std::vector<DataType> supportedTypes
2961 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2962 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2964 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2966 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2967 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2969 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2979 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2981 ValidateNumInputs(workloadInfo, descriptorName, 1);
2982 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2987 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2988 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2990 ValidatePointer(m_Weight, descriptorName,
"weight");
2992 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2993 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2995 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2998 if (m_Parameters.m_BiasEnabled)
3000 ValidatePointer(m_Bias, descriptorName,
"bias");
3002 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
3006 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
3009 ValidatePerAxisQuantization(inputTensorInfo,
3012 optionalBiasTensorInfo,
3015 std::vector<DataType> supportedTypes =
3025 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3026 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3031 const std::string descriptorName{
"TransposeQueueDescriptor"};
3033 ValidateNumInputs(workloadInfo, descriptorName, 1);
3034 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3041 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
3042 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
3044 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3046 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3049 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3050 "must match dst dimension " + to_string(i) +
3051 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3055 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3060 const std::string descriptorName{
"TransposeQueueDescriptor"};
3062 ValidateNumInputs(workloadInfo, descriptorName, 1);
3063 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3068 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3073 const std::string descriptorName{
"QLstmQueueDescriptor"};
3076 ValidateNumInputs(workloadInfo, descriptorName, 3);
3077 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3089 std::vector<DataType> inputOutputSupportedTypes =
3094 std::vector<DataType> cellStateSupportedTypes =
3099 std::vector<DataType> weightsSupportedTypes =
3104 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3109 std::vector<DataType> biasSupportedTypes =
3115 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3116 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3117 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3119 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3120 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3121 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3124 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3125 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3126 "outputStateIn",
"outputStateOut");
3127 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3130 const uint32_t numBatches = inputInfo.GetShape()[0];
3131 const uint32_t inputSize = inputInfo.GetShape()[1];
3132 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3133 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3136 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3137 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3138 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
3140 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3141 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
3142 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
3145 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3146 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3147 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
3149 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3150 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3151 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
3153 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3154 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3155 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
3157 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3158 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3159 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
3160 " RecurrentToForgetWeights");
3162 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3163 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3164 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3166 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3167 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3168 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3171 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3173 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3174 "inputToForgetWeights",
"inputToCellWeights");
3175 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3176 "inputToForgetWeights",
"inputToOutputWeights");
3178 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3179 "inputToForgetWeights",
"recurrentToForgeteights");
3180 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3181 "inputToForgetWeights",
"recurrentToCellWeights");
3182 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3183 "inputToForgetWeights",
"recurrentToOutputWeights");
3186 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3187 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3188 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
3190 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3191 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3192 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
3194 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3195 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3196 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
3199 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3201 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3202 "forgetGateBias",
"cellBias");
3203 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3204 "forgetGateBias",
"outputGateBias");
3207 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3208 !m_Parameters.m_CifgEnabled) ||
3209 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3210 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3212 if (!allCifgParamsPresentOrNot)
3215 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3216 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3217 "set appropriately.");
3220 if (!m_Parameters.m_CifgEnabled)
3223 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3224 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3226 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3227 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3228 " RecurrentToInputWeights");
3230 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3231 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3234 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3235 "inputToForgetWeights",
"inputToInputWeights");
3236 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3237 "inputToForgetWeights",
"recurrentToInputWeights");
3238 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3239 "forgetGateBias",
"inputGateBias");
3243 bool allPeepholeWeightsPresentOrNot =
3244 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3245 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3246 || (!m_CellToInputWeights && !m_CellToForgetWeights
3247 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3249 if (!allPeepholeWeightsPresentOrNot)
3252 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3253 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3254 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3258 if (m_Parameters.m_PeepholeEnabled)
3260 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3261 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3262 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3264 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3265 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3266 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3267 "cellToForgetWeight",
"cellToOutputWeights");
3269 if (!m_Parameters.m_CifgEnabled)
3271 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3272 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3273 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3274 "cellToForgetWeights",
"cellToInputWeights");
3279 bool allLayerNormWeightsPresentOrNot =
3280 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3281 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3282 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3283 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3285 if (!allLayerNormWeightsPresentOrNot)
3288 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3289 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3290 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3291 "only be present when Layer Norm is enabled and CIFG is disabled. " 3292 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3295 if (m_Parameters.m_LayerNormEnabled)
3297 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3298 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3299 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3301 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3302 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3303 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3304 "forgetLayerNormWeights",
"cellLayerNormWeights");
3306 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3307 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3308 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3309 "forgetLayerNormWeights",
"outputLayerNormWeights");
3311 if (!m_Parameters.m_CifgEnabled)
3313 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3314 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3315 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3316 "forgetLayerNormWeights",
"inputLayerNormWeights");
3321 bool correctProjectionTensorsPresent =
3322 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3323 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3324 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3326 if (!correctProjectionTensorsPresent)
3329 ": If projection is enabled, ProjectionWeights should be present and " 3330 "ProjectionBias is optional. If projection is disabled, neither " 3331 "ProjectionWeights nor ProjectionBias should be present.");
3334 if (m_Parameters.m_ProjectionEnabled)
3336 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3337 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3338 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3340 if (m_ProjectionBias)
3342 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3343 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3344 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3348 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3349 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3351 ": If projection is disabled, output quantization info (scale, offset) " 3352 "should match HiddenStateScale and HiddenStateZeroPoint.");
3359 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3362 ValidateNumInputs(workloadInfo, descriptorName, 3);
3363 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3373 std::vector<DataType> inputOutputSupportedTypes =
3378 std::vector<DataType> cellStateSupportedTypes =
3383 std::vector<DataType> weightsSupportedTypes =
3388 std::vector<DataType> biasSupportedTypes =
3394 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3395 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3396 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3398 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3399 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3402 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3403 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3404 "outputStateIn",
"outputStateOut");
3405 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3408 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3409 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3410 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3413 const uint32_t numBatches = inputInfo.GetShape()[0];
3414 const uint32_t inputSize = inputInfo.GetShape()[1];
3415 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3418 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3419 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3420 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3421 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3422 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3425 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3426 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3427 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3429 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3430 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3431 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3433 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3434 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3435 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3437 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3438 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3439 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3441 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3442 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3443 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3445 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3446 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3447 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3448 " RecurrentToForgetWeights");
3450 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3451 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3452 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3454 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3455 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3456 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3459 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3461 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3462 "inputToInputWeights",
"inputToForgetWeights");
3463 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3464 "inputToInputWeights",
"inputToCellWeights");
3465 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3466 "inputToInputWeights",
"inputToOutputWeights");
3468 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3469 "inputToInputWeights",
"recurrentToInputWeights");
3470 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3471 "inputToInputWeights",
"recurrentToForgeteights");
3472 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3473 "inputToInputWeights",
"recurrentToCellWeights");
3474 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3475 "inputToInputWeights",
"recurrentToOutputWeights");
3478 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3479 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3480 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3481 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3482 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3483 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3485 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3486 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3487 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3488 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3489 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3490 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3491 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3492 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3495 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3496 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3497 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3499 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3500 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3501 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3503 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3504 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3505 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3507 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3508 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3509 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3512 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3514 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3515 "inputGateBias",
"forgetGateBias");
3516 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3517 "inputGateBias",
"cellBias");
3518 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3519 "inputGateBias",
"outputGateBias");
3522 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3523 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3524 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3525 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3530 const std::string descriptorName{
"AbsQueueDescriptor"};
3532 ValidateNumInputs(workloadInfo, descriptorName, 1);
3533 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3538 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3540 std::vector<DataType> supportedTypes =
3551 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3552 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3557 const std::string descriptorName{
"SliceQueueDescriptor"};
3559 ValidateNumInputs(workloadInfo, descriptorName, 1);
3560 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3565 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3573 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3576 if (m_Parameters.m_Begin.size() != rank)
3579 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3581 if (m_Parameters.m_Size.size() != rank)
3584 ": Length of size descriptor must equal rank " + std::to_string(rank));
3589 for (
unsigned int i = 0u; i < rank; ++i)
3591 if (m_Parameters.m_Size[i] != outputShape[i])
3600 for(
unsigned int i = 0u; i < rank; ++i)
3602 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3605 std::to_string(i) +
" exceeds input size.");
3612 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3614 ValidateNumInputs(workloadInfo, descriptorName, 1);
3615 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3620 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3621 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3623 std::vector<DataType> supportedTypes =
3633 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3634 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3636 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3638 if (m_Parameters.m_BlockSize == 0)
3644 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3649 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3652 "must be divisible by block size.");
3656 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3659 "must be divisible by the square of block size." );
3665 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3667 ValidateNumInputs(workloadInfo, descriptorName, 2);
3668 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3674 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3689 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3691 ValidateNumInputs(workloadInfo, descriptorName, 1);
3692 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3697 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3699 std::vector<DataType> supportedTypes =
3710 std::vector<DataType> logicalSupportedTypes =
3717 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3721 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3725 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3730 const std::string descriptorName{
"RankQueueDescriptor"};
3732 ValidateNumInputs(workloadInfo, descriptorName, 1);
3733 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3738 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
3739 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3741 std::vector<DataType> supportedTypes =
3753 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3754 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3759 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3761 ValidateNumInputs(workloadInfo, descriptorName, 2);
3762 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3768 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3793 const std::string descriptorName{
"ReduceQueueDescriptor"};
3795 ValidateNumInputs(workloadInfo, descriptorName, 1);
3796 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3801 std::vector<DataType> supportedTypes =
3812 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3813 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3820 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3832 std::vector<DataType> supportedTypes =
3838 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3847 "input_" + std::to_string(i));
3854 "LstmQueueDescriptor",
3856 "output_" + std::to_string(i));
3862 if (m_Parameters.m_ClippingThresCell < 0.0f)
3866 if (m_Parameters.m_ClippingThresProj < 0.0f)
3871 unsigned int batchIndx = 0;
3872 unsigned int inputIndx = 1;
3873 uint32_t timeStep = 1;
3874 unsigned int timeIndx = 1;
3876 if (m_Parameters.m_TimeMajor)
3887 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
3888 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
3889 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
3890 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
3893 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 3, (timeStep * n_batch * n_input),
3894 descriptorName +
" input_0");
3896 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
3897 descriptorName +
" input_1");
3899 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
3900 descriptorName +
" input_2");
3903 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 3, (timeStep * n_batch * n_output),
3904 descriptorName +
" output_0");
3907 if ( m_InputToInputWeights )
3909 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
3910 (n_cell * n_input),
"InputLayerNormWeights");
3913 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
3914 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
3915 (n_cell * n_input),
"InputToForgetWeights");
3917 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
3918 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
3919 (n_cell * n_input),
"InputToCellWeights");
3921 if ( m_RecurrentToInputWeights )
3923 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
3924 (n_cell * n_output),
"RecurrentToInputWeights");
3927 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
3928 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
3929 (n_cell * n_output),
"RecurrentToForgetWeights");
3931 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
3932 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
3933 (n_cell * n_output),
"RecurrentToCellWeights");
3937 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
3938 !m_Parameters.m_CifgEnabled) ||
3939 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3940 m_Parameters.m_CifgEnabled));
3941 if (!cifg_weights_all_or_none)
3944 "RecurrentToInputWeights must either both be present (regular LSTM) " 3945 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 3949 if ( m_CellToInputWeights )
3951 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
3952 n_cell,
"CellToInputWeights");
3954 if ( m_CellToForgetWeights )
3956 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
3957 n_cell,
"CellToForgetWeights");
3959 if ( m_CellToOutputWeights )
3961 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
3962 n_cell,
"CellToOutputWeights");
3966 bool peephole_weights_all_or_none =
3967 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3968 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3969 || ( !m_CellToInputWeights && !m_CellToForgetWeights
3970 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3971 if (!peephole_weights_all_or_none)
3977 if (m_Parameters.m_CifgEnabled)
3979 if (m_InputGateBias)
3986 if (!m_InputGateBias)
3989 "must be present.");
3991 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
3992 n_cell,
"InputGateBias");
3995 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
3996 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
3998 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
3999 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
4001 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
4002 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
4004 if (m_ProjectionWeights)
4006 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
4007 (n_cell * n_output),
"ProjectionWeights");
4009 if (m_ProjectionBias)
4011 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
4018 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
4019 !m_Parameters.m_ProjectionEnabled)
4020 || (m_ProjectionWeights && !m_ProjectionBias &&
4021 m_Parameters.m_ProjectionEnabled)
4022 || (m_ProjectionWeights && m_ProjectionBias &&
4023 m_Parameters.m_ProjectionEnabled));
4024 if (!projecton_tensors_consistent)
4033 if (m_InputLayerNormWeights)
4035 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
4037 if (m_ForgetLayerNormWeights)
4039 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
4041 if (m_CellLayerNormWeights)
4043 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
4045 if (m_OutputLayerNormWeights)
4047 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
4050 if (m_Parameters.m_LayerNormEnabled)
4052 if (!m_Parameters.m_CifgEnabled)
4054 if (!m_InputLayerNormWeights)
4057 "disabled but InputLayerNormWeights are not present");
4059 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
4060 1, n_cell,
"InputLayerNormWeights");
4062 else if (m_InputLayerNormWeights)
4068 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
4069 "ForgetLayerNormWeights");
4070 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
4072 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
4073 "OutputLayerNormWeights");
4074 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
4076 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
4077 "CellLayerNormWeights");
4078 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
4080 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
4083 "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
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()
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
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
void Validate(const WorkloadInfo &workloadInfo) const
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
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