18 #include <fmt/format.h> 28 switch (inputDataType)
30 case DataType::Float16:
31 return DataType::Float16;
33 case DataType::Float32:
34 return DataType::Float32;
35 case DataType::QAsymmS8:
36 return DataType::Signed32;
37 case DataType::QAsymmU8:
38 return DataType::Signed32;
39 case DataType::QSymmS8:
40 return DataType::Signed32;
41 case DataType::QSymmS16:
42 return DataType::Signed32;
45 return DataType::Float32;
55 std::string to_string(T value)
57 std::ostringstream os;
63 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
68 paramName +
" parameter must be set.");
73 void ValidateTensorShapesMatch(
const TensorInfo& first,
75 std::string
const& descName,
76 std::string
const& firstName,
77 std::string
const& secondName)
82 + firstName +
" & " + secondName +
" must have identical shapes");
87 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
92 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
98 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
103 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
109 void ValidateTensorNumDimensions(
const TensorInfo& tensor,
110 std::string
const& descName,
111 unsigned int numDimensions,
112 std::string
const& tensorName)
118 tensorName +
" tensor.");
123 void ValidateTensorNumElements(
const TensorInfo& tensor,
124 std::string
const& descName,
125 unsigned int numElements,
126 std::string
const& tensorName)
132 tensorName +
" tensor.");
137 void ValidateTensorNumDimNumElem(
const TensorInfo& tensorInfo,
138 unsigned int numDimension,
139 unsigned int numElements,
140 std::string
const& tensorName)
142 const std::string functionName{
"ValidateTensorNumDimNumElem"};
143 ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName);
144 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
149 const std::string& descName, std::string
const& tensorName)
158 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
163 ": Expected data type which supports per-axis quantization scheme but got " +
169 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
171 const std::string& descName,
172 std::string
const& firstName,
173 std::string
const& secondName)
185 if (firstDataType != secondDataType)
188 " must be of the same quantized type, " +
196 " must have the same quantization space, " +
205 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
208 const std::string& descName)
211 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 213 constexpr
float tolerance = 0.0001f;
214 if (std::abs(biasScale - expectedScale) > tolerance)
217 ARMNN_LOG(
warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
218 " for bias quantization scale (product of input and weight scales), but got " <<
219 biasScale <<
". Using scale provided.";
235 if (weightScales.size() != biasScales.size())
237 std::stringstream msg;
238 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, " 239 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
240 <<
", biases=" << biasScales.size();
244 for (
size_t i = 0ul; i < biasScales.size(); ++i)
247 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
259 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
260 unsigned int numExpected,
261 const std::string& descName,
262 const std::string& varName)
264 if (vec.empty() && numExpected > 0)
269 for (
unsigned int i = 0; i < numExpected; ++i)
279 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
282 std::string
const& descName,
283 std::string
const& firstName,
284 std::string
const& secondName)
291 + firstName +
" & " + secondName
292 +
" must have the same number of dimensions in order to be broadcasted");
295 std::vector<uint32_t> outputDims(numDims, 0u);
296 for (uint32_t i = 0; i < numDims; i++)
299 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
300 if (dimsNotEqual && dimsNotOne)
306 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
307 if (broadcastShape != output.
GetShape())
310 + firstName +
" & " + secondName
311 +
" does not match the output shape");
317 const std::vector<armnn::DataType>& supportedTypes,
318 std::string
const& descName)
320 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
321 if (iterator == supportedTypes.end())
328 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
330 std::string
const& descName,
331 std::string
const& firstName,
332 std::string
const& secondName)
337 " must have identical data types.");
342 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
344 std::string
const& descName,
345 std::string
const& firstName,
346 std::string
const& secondName)
351 " must have the same number of elements.");
355 void ValidateWeightDataType(
const TensorInfo& inputInfo,
357 const std::string& descName)
362 const std::vector<DataType> validTypes =
369 ValidateDataTypes(weightInfo, validTypes, descName);
373 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
377 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
378 const std::string& descName,
379 const std::string& tensorName)
385 "not set on tensor {1}.", descName, tensorName));
389 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
390 const std::string& descName,
391 const std::string& tensorName)
394 if (quantizationOffset != 0)
397 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
398 descName, tensorName, quantizationOffset));
402 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
406 const std::string& descName)
413 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
415 if (!canHavePerAxisQuantization)
418 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 419 "per-axis quantization.", descName,
"weight"));
423 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
424 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
425 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
433 "{}: Per-axis quantization parameters not set on bias tensor, " 434 "despite being set on weight tensor.", descName));
437 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
438 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
439 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
447 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 449 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
450 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
456 const std::string descriptorName{
"MapQueueDescriptor"};
458 ValidateNumInputs(workloadInfo, descriptorName, 1);
459 ValidateNumOutputs(workloadInfo, descriptorName, 0);
461 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
466 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
474 const std::string descriptorName{
"UnmapQueueDescriptor"};
476 ValidateNumInputs(workloadInfo, descriptorName, 1);
477 ValidateNumOutputs(workloadInfo, descriptorName, 0);
479 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
484 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
492 const std::string descriptorName{
"MemCopyQueueDescriptor"};
494 ValidateNumInputs(workloadInfo, descriptorName, 1);
495 ValidateNumOutputs(workloadInfo, descriptorName , 1);
500 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
501 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
506 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
510 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
515 "{0}: Invalid NULL input {1}.", descriptorName, i));
528 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
529 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
541 "Number of input infos ({0}) does not match the number of output infos ({1})",
551 "Number of elements for tensor input and output {} does not match", i ));
563 "Number of inputs ({0}) does not match the number of outputs ({1})",
567 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
584 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
585 ValidateNumOutputs(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");
1534 void ResizeBilinearQueueDescriptor::Validate(
const WorkloadInfo& workloadInfo)
const 1536 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1538 ValidateNumInputs(workloadInfo, descriptorName, 1);
1539 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1544 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1545 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1547 std::vector<DataType> supportedTypes =
1557 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1558 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1561 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1562 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1563 if (inputBatchSize != outputBatchSize)
1566 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1567 descriptorName, inputBatchSize, outputBatchSize));
1573 if (inputChannelCount != outputChannelCount)
1576 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1577 descriptorName, inputChannelCount, outputChannelCount));
1583 const std::string descriptorName{
"ResizeQueueDescriptor"};
1585 ValidateNumInputs(workloadInfo, descriptorName, 1);
1586 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1591 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1592 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1594 std::vector<DataType> supportedTypes =
1604 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1605 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1608 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1609 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1610 if (inputBatchSize != outputBatchSize)
1613 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1614 descriptorName, inputBatchSize, outputBatchSize));
1620 if (inputChannelCount != outputChannelCount)
1623 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1624 descriptorName, inputChannelCount, outputChannelCount));
1630 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1632 ValidateNumInputs(workloadInfo, descriptorName, 1);
1633 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1638 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1639 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1641 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1643 if (m_Parameters.m_Min > m_Parameters.m_Max)
1651 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1653 ValidateNumInputs(workloadInfo, descriptorName, 1);
1654 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1664 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1667 std::vector<DataType> supportedTypes =
1674 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1675 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1680 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1682 ValidateNumInputs(workloadInfo, descriptorName, 1);
1683 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1693 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1696 std::vector<DataType> supportedTypes =
1706 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1707 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1712 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1714 ValidateNumInputs(workloadInfo, descriptorName, 1);
1715 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1720 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1722 std::vector<DataType> supportedTypes =
1729 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1730 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1735 const std::string descriptorName{
"ConstantQueueDescriptor"};
1737 ValidateNumInputs(workloadInfo, descriptorName, 0);
1738 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1746 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1749 std::vector<DataType> supportedTypes =
1761 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1766 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1768 ValidateNumInputs(workloadInfo, descriptorName, 1);
1769 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1774 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1777 std::vector<DataType> supportedTypes =
1789 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1790 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1795 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1797 ValidateNumInputs(workloadInfo, descriptorName, 1);
1798 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1803 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1804 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1806 if (m_Parameters.m_BlockShape.size() != 2)
1811 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1814 "dimensions as Block Shape.");
1819 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1820 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1824 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1825 widthPad.first + widthPad.second;
1826 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1827 heightPad.first + heightPad.second;
1829 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1831 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1833 if (numOutputElements != numInputElements)
1836 to_string(numInputElements) +
" after padding but output tensor has " +
1837 to_string(numOutputElements) +
" elements.");
1840 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1843 "divisible by Block Shape in all spatial dimensions");
1846 std::vector<DataType> supportedTypes =
1856 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1857 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1862 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1864 ValidateNumInputs(workloadInfo, descriptorName, 1);
1865 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1870 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1871 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1873 std::vector<DataType> supportedTypes =
1883 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1884 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1886 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1888 if (m_Parameters.m_BlockSize == 0)
1894 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1899 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1902 "by block size in all spatial dimensions");
1906 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1909 "must be divisible by the square of block size." );
1915 const std::string descriptorName{
"FloorQueueDescriptor"};
1917 ValidateNumInputs(workloadInfo, descriptorName, 1);
1918 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1923 std::vector<DataType> supportedTypes =
1931 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1932 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1933 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1934 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1941 const std::string descriptorName{
"LstmQueueDescriptor"};
1953 std::vector<DataType> supportedTypes =
1962 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1971 "input_" + std::to_string(i));
1978 "LstmQueueDescriptor",
1980 "output_" + std::to_string(i));
1986 if (m_Parameters.m_ClippingThresCell < 0.0f)
1990 if (m_Parameters.m_ClippingThresProj < 0.0f)
1998 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
1999 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
2000 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
2001 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
2004 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
2005 descriptorName +
" input_0");
2007 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
2008 descriptorName +
" input_1");
2010 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
2011 descriptorName +
" input_2");
2013 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
2014 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
2015 descriptorName +
" output_0");
2018 descriptorName +
" output_1");
2021 descriptorName +
" output_2");
2024 descriptorName +
" output_3");
2027 if ( m_InputToInputWeights )
2029 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
2030 (n_cell * n_input),
"InputLayerNormWeights");
2033 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
2034 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
2035 (n_cell * n_input),
"InputToForgetWeights");
2037 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
2038 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
2039 (n_cell * n_input),
"InputToCellWeights");
2041 if ( m_RecurrentToInputWeights )
2043 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
2044 (n_cell * n_output),
"RecurrentToInputWeights");
2047 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
2048 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
2049 (n_cell * n_output),
"RecurrentToForgetWeights");
2051 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
2052 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
2053 (n_cell * n_output),
"RecurrentToCellWeights");
2057 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
2058 !m_Parameters.m_CifgEnabled) ||
2059 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
2060 m_Parameters.m_CifgEnabled));
2061 if (!cifg_weights_all_or_none)
2064 "RecurrentToInputWeights must either both be present (regular LSTM) " 2065 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 2069 if ( m_CellToInputWeights )
2071 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
2072 n_cell,
"CellToInputWeights");
2074 if ( m_CellToForgetWeights )
2076 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
2077 n_cell,
"CellToForgetWeights");
2079 if ( m_CellToOutputWeights )
2081 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
2082 n_cell,
"CellToOutputWeights");
2086 bool peephole_weights_all_or_none =
2087 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
2088 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
2089 || ( !m_CellToInputWeights && !m_CellToForgetWeights
2090 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
2091 if (!peephole_weights_all_or_none)
2097 if (m_Parameters.m_CifgEnabled)
2099 if (m_InputGateBias)
2106 if (!m_InputGateBias)
2109 "must be present.");
2111 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
2112 n_cell,
"InputGateBias");
2115 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2116 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
2118 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2119 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
2121 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2122 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
2124 if (m_ProjectionWeights)
2126 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
2127 (n_cell * n_output),
"ProjectionWeights");
2129 if (m_ProjectionBias)
2131 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
2138 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2139 !m_Parameters.m_ProjectionEnabled)
2140 || (m_ProjectionWeights && !m_ProjectionBias &&
2141 m_Parameters.m_ProjectionEnabled)
2142 || (m_ProjectionWeights && m_ProjectionBias &&
2143 m_Parameters.m_ProjectionEnabled));
2144 if (!projecton_tensors_consistent)
2153 if (m_InputLayerNormWeights)
2155 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2157 if (m_ForgetLayerNormWeights)
2159 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2161 if (m_CellLayerNormWeights)
2163 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2165 if (m_OutputLayerNormWeights)
2167 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2170 if (m_Parameters.m_LayerNormEnabled)
2172 if (!m_Parameters.m_CifgEnabled)
2174 if (!m_InputLayerNormWeights)
2177 "disabled but InputLayerNormWeights are not present");
2179 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2180 1, n_cell,
"InputLayerNormWeights");
2182 else if (m_InputLayerNormWeights)
2188 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2189 "ForgetLayerNormWeights");
2190 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2192 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2193 "OutputLayerNormWeights");
2194 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2196 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2197 "CellLayerNormWeights");
2198 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2200 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2203 "normalisation weights are present.");
2209 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2211 ValidateNumInputs(workloadInfo, descriptorName, 1);
2212 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2227 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2232 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2234 ValidateNumInputs(workloadInfo, descriptorName, 1);
2235 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2250 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2255 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2257 ValidateNumInputs(workloadInfo, descriptorName, 1);
2258 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2273 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2278 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2280 ValidateNumInputs(workloadInfo, descriptorName, 1);
2281 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2296 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2301 const std::string descriptorName{
"DivisionQueueDescriptor"};
2303 ValidateNumInputs(workloadInfo, descriptorName, 2);
2304 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2310 std::vector<DataType> supportedTypes =
2321 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2322 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2323 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2325 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2335 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2337 ValidateNumInputs(workloadInfo, descriptorName, 2);
2338 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2344 std::vector<DataType> supportedTypes =
2355 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2356 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2357 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2359 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2369 const std::string descriptorName{
"MaximumQueueDescriptor"};
2371 ValidateNumInputs(workloadInfo, descriptorName, 2);
2372 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2378 std::vector<DataType> supportedTypes =
2389 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2390 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2391 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2393 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2403 const std::string descriptorName{
"MeanQueueDescriptor"};
2405 ValidateNumInputs(workloadInfo, descriptorName, 1);
2406 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2411 std::vector<DataType> supportedTypes =
2423 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2424 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2426 if (m_Parameters.m_KeepDims)
2428 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2430 else if (m_Parameters.m_Axis.empty())
2432 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2436 unsigned int outputDim =
2438 ValidateTensorNumDimensions(outputTensorInfo,
2440 outputDim > 0 ? outputDim : 1,
2447 const std::string descriptorName{
"PadQueueDescriptor"};
2449 ValidateNumInputs(workloadInfo, descriptorName, 1);
2450 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2456 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2461 "as there are dimensions in the input tensor that is " +
2463 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2469 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2471 ValidateNumInputs(workloadInfo, descriptorName, 1);
2472 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2477 std::vector<DataType> supportedTypes =
2488 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2498 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2500 ValidateNumInputs(workloadInfo, descriptorName, 1);
2501 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2506 std::vector<DataType> supportedTypes =
2516 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2517 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2522 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2524 ValidateNumInputs(workloadInfo, descriptorName, 1);
2525 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2530 std::vector<DataType> supportedTypes =
2540 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2541 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2543 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2552 if (m_Parameters.m_Begin.size() != rank)
2557 if (m_Parameters.m_End.size() != rank)
2562 if (m_Parameters.m_Stride.size() != rank)
2568 for (
auto& stride : m_Parameters.m_Stride)
2579 const std::string descriptorName{
"MinimumQueueDescriptor"};
2581 ValidateNumInputs(workloadInfo, descriptorName, 2);
2582 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2588 std::vector<DataType> supportedTypes =
2599 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2600 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2601 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2603 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2613 const std::string descriptorName{
"DebugQueueDescriptor"};
2615 ValidateNumInputs(workloadInfo, descriptorName, 1);
2616 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2621 const std::string descriptorName{
"EqualQueueDescriptor"};
2623 ValidateNumInputs(workloadInfo, descriptorName, 2);
2624 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2630 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2645 const std::string descriptorName{
"GreaterQueueDescriptor"};
2647 ValidateNumInputs(workloadInfo, descriptorName, 2);
2648 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2654 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2669 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2671 ValidateNumInputs(workloadInfo, descriptorName, 1);
2672 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2677 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2679 std::vector<DataType> supportedTypes =
2689 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2690 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2695 const std::string descriptorName{
"GatherQueueDescriptor"};
2697 ValidateNumInputs(workloadInfo, descriptorName, 2);
2698 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2709 std::vector<DataType> supportedTypes =
2720 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2722 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2725 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2730 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2732 ValidateNumInputs(workloadInfo, descriptorName, 2);
2740 if (m_Anchors ==
nullptr)
2747 const TensorInfo& anchorsInfo = m_Anchors->GetTensorInfo();
2754 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2755 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2756 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2758 const std::vector<DataType> supportedInputTypes =
2768 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2769 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2770 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2772 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2773 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2774 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2775 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2778 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2779 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2780 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2781 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2783 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2786 "must be positive and less than or equal to 1.");
2789 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2792 "should be equal to number of classes + 1.");
2798 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2800 ValidateNumInputs(workloadInfo, descriptorName, 1);
2801 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2811 std::vector<DataType> supportedTypes =
2818 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2823 const std::string& descriptorName{
"MergeQueueDescriptor"};
2825 ValidateNumInputs(workloadInfo, descriptorName, 2);
2826 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2832 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2833 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2835 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2836 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2841 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2843 ValidateNumInputs(workloadInfo, descriptorName, 1);
2844 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2849 std::vector<DataType> supportedTypes =
2862 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2863 ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName);
2868 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2870 ValidateNumInputs(workloadInfo, descriptorName, 2);
2871 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2879 std::vector<DataType> supportedTypes =
2888 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2889 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2891 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2892 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2894 ValidateTensorShapesMatch(inputTensorInfo0,
2900 ValidateTensorShapesMatch(inputTensorInfo0,
2914 const std::string& descriptorName{
"PreluQueueDescriptor"};
2916 ValidateNumInputs(workloadInfo, descriptorName, 2);
2917 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2923 std::vector<DataType> supportedTypes
2933 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2934 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2936 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2938 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2939 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2941 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2951 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2953 ValidateNumInputs(workloadInfo, descriptorName, 1);
2954 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2959 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2960 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2962 ValidatePointer(m_Weight, descriptorName,
"weight");
2964 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2965 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2967 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2970 if (m_Parameters.m_BiasEnabled)
2972 ValidatePointer(m_Bias, descriptorName,
"bias");
2974 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
2978 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2981 ValidatePerAxisQuantization(inputTensorInfo,
2984 optionalBiasTensorInfo,
2987 std::vector<DataType> supportedTypes =
2997 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2998 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3003 const std::string descriptorName{
"TransposeQueueDescriptor"};
3005 ValidateNumInputs(workloadInfo, descriptorName, 1);
3006 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3013 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
3014 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
3016 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3018 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3021 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3022 "must match dst dimension " + to_string(i) +
3023 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3027 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3032 const std::string descriptorName{
"TransposeQueueDescriptor"};
3034 ValidateNumInputs(workloadInfo, descriptorName, 1);
3035 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3040 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3045 const std::string descriptorName{
"QLstmQueueDescriptor"};
3048 ValidateNumInputs(workloadInfo, descriptorName, 3);
3049 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3061 std::vector<DataType> inputOutputSupportedTypes =
3066 std::vector<DataType> cellStateSupportedTypes =
3071 std::vector<DataType> weightsSupportedTypes =
3076 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3081 std::vector<DataType> biasSupportedTypes =
3087 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3088 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3089 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3091 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3092 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3093 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3096 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3097 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3098 "outputStateIn",
"outputStateOut");
3099 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3102 const uint32_t numBatches = inputInfo.GetShape()[0];
3103 const uint32_t inputSize = inputInfo.GetShape()[1];
3104 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3105 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3108 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3109 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3110 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
3112 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3113 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
3114 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
3117 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3118 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3119 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
3121 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3122 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3123 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
3125 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3126 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3127 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
3129 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3130 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3131 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
3132 " RecurrentToForgetWeights");
3134 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3135 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3136 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3138 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3139 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3140 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3143 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3145 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3146 "inputToForgetWeights",
"inputToCellWeights");
3147 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3148 "inputToForgetWeights",
"inputToOutputWeights");
3150 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3151 "inputToForgetWeights",
"recurrentToForgeteights");
3152 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3153 "inputToForgetWeights",
"recurrentToCellWeights");
3154 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3155 "inputToForgetWeights",
"recurrentToOutputWeights");
3158 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3159 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3160 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
3162 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3163 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3164 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
3166 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3167 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3168 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
3171 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3173 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3174 "forgetGateBias",
"cellBias");
3175 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3176 "forgetGateBias",
"outputGateBias");
3179 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3180 !m_Parameters.m_CifgEnabled) ||
3181 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3182 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3184 if (!allCifgParamsPresentOrNot)
3187 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3188 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3189 "set appropriately.");
3192 if (!m_Parameters.m_CifgEnabled)
3195 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3196 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3198 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3199 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3200 " RecurrentToInputWeights");
3202 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3203 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3206 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3207 "inputToForgetWeights",
"inputToInputWeights");
3208 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3209 "inputToForgetWeights",
"recurrentToInputWeights");
3210 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3211 "forgetGateBias",
"inputGateBias");
3215 bool allPeepholeWeightsPresentOrNot =
3216 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3217 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3218 || (!m_CellToInputWeights && !m_CellToForgetWeights
3219 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3221 if (!allPeepholeWeightsPresentOrNot)
3224 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3225 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3226 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3230 if (m_Parameters.m_PeepholeEnabled)
3232 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3233 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3234 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3236 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3237 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3238 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3239 "cellToForgetWeight",
"cellToOutputWeights");
3241 if (!m_Parameters.m_CifgEnabled)
3243 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3244 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3245 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3246 "cellToForgetWeights",
"cellToInputWeights");
3251 bool allLayerNormWeightsPresentOrNot =
3252 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3253 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3254 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3255 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3257 if (!allLayerNormWeightsPresentOrNot)
3260 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3261 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3262 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3263 "only be present when Layer Norm is enabled and CIFG is disabled. " 3264 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3267 if (m_Parameters.m_LayerNormEnabled)
3269 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3270 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3271 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3273 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3274 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3275 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3276 "forgetLayerNormWeights",
"cellLayerNormWeights");
3278 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3279 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3280 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3281 "forgetLayerNormWeights",
"outputLayerNormWeights");
3283 if (!m_Parameters.m_CifgEnabled)
3285 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3286 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3287 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3288 "forgetLayerNormWeights",
"inputLayerNormWeights");
3293 bool correctProjectionTensorsPresent =
3294 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3295 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3296 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3298 if (!correctProjectionTensorsPresent)
3301 ": If projection is enabled, ProjectionWeights should be present and " 3302 "ProjectionBias is optional. If projection is disabled, neither " 3303 "ProjectionWeights nor ProjectionBias should be present.");
3306 if (m_Parameters.m_ProjectionEnabled)
3308 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3309 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3310 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3312 if (m_ProjectionBias)
3314 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3315 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3316 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3320 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3321 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3323 ": If projection is disabled, output quantization info (scale, offset) " 3324 "should match HiddenStateScale and HiddenStateZeroPoint.");
3331 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3334 ValidateNumInputs(workloadInfo, descriptorName, 3);
3335 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3345 std::vector<DataType> inputOutputSupportedTypes =
3350 std::vector<DataType> cellStateSupportedTypes =
3355 std::vector<DataType> weightsSupportedTypes =
3360 std::vector<DataType> biasSupportedTypes =
3366 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3367 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3368 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3370 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3371 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3374 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3375 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3376 "outputStateIn",
"outputStateOut");
3377 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3380 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3381 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3382 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3385 const uint32_t numBatches = inputInfo.GetShape()[0];
3386 const uint32_t inputSize = inputInfo.GetShape()[1];
3387 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3390 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3391 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3392 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3393 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3394 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3397 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3398 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3399 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3401 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3402 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3403 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3405 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3406 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3407 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3409 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3410 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3411 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3413 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3414 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3415 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3417 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3418 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3419 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3420 " RecurrentToForgetWeights");
3422 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3423 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3424 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3426 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3427 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3428 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3431 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3433 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3434 "inputToInputWeights",
"inputToForgetWeights");
3435 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3436 "inputToInputWeights",
"inputToCellWeights");
3437 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3438 "inputToInputWeights",
"inputToOutputWeights");
3440 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3441 "inputToInputWeights",
"recurrentToInputWeights");
3442 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3443 "inputToInputWeights",
"recurrentToForgeteights");
3444 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3445 "inputToInputWeights",
"recurrentToCellWeights");
3446 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3447 "inputToInputWeights",
"recurrentToOutputWeights");
3450 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3451 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3452 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3453 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3454 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3455 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3457 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3458 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3459 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3460 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3461 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3462 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3463 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3464 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3467 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3468 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3469 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3471 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3472 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3473 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3475 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3476 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3477 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3479 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3480 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3481 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3484 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3486 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3487 "inputGateBias",
"forgetGateBias");
3488 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3489 "inputGateBias",
"cellBias");
3490 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3491 "inputGateBias",
"outputGateBias");
3494 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3495 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3496 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3497 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3502 const std::string descriptorName{
"AbsQueueDescriptor"};
3504 ValidateNumInputs(workloadInfo, descriptorName, 1);
3505 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3510 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3512 std::vector<DataType> supportedTypes =
3523 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3524 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3529 const std::string descriptorName{
"SliceQueueDescriptor"};
3531 ValidateNumInputs(workloadInfo, descriptorName, 1);
3532 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3537 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3545 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3548 if (m_Parameters.m_Begin.size() != rank)
3551 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3553 if (m_Parameters.m_Size.size() != rank)
3556 ": Length of size descriptor must equal rank " + std::to_string(rank));
3561 for (
unsigned int i = 0u; i < rank; ++i)
3563 if (m_Parameters.m_Size[i] != outputShape[i])
3572 for(
unsigned int i = 0u; i < rank; ++i)
3574 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3577 std::to_string(i) +
" exceeds input size.");
3584 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3586 ValidateNumInputs(workloadInfo, descriptorName, 1);
3587 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3592 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3593 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3595 std::vector<DataType> supportedTypes =
3605 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3606 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3608 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3610 if (m_Parameters.m_BlockSize == 0)
3616 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3621 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3624 "must be divisible by block size.");
3628 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3631 "must be divisible by the square of block size." );
3637 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3639 ValidateNumInputs(workloadInfo, descriptorName, 2);
3640 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3646 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3661 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3663 ValidateNumInputs(workloadInfo, descriptorName, 1);
3664 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3669 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3671 std::vector<DataType> supportedTypes =
3682 std::vector<DataType> logicalSupportedTypes =
3689 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3693 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3697 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3702 const std::string descriptorName{
"RankQueueDescriptor"};
3704 ValidateNumInputs(workloadInfo, descriptorName, 1);
3705 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3710 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
3711 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3713 std::vector<DataType> supportedTypes =
3725 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3726 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3731 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3733 ValidateNumInputs(workloadInfo, descriptorName, 2);
3734 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3740 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3765 const std::string descriptorName{
"ReduceQueueDescriptor"};
3767 ValidateNumInputs(workloadInfo, descriptorName, 1);
3768 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3773 std::vector<DataType> supportedTypes =
3784 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3785 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3792 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3804 std::vector<DataType> supportedTypes =
3810 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3819 "input_" + std::to_string(i));
3826 "LstmQueueDescriptor",
3828 "output_" + std::to_string(i));
3834 if (m_Parameters.m_ClippingThresCell < 0.0f)
3838 if (m_Parameters.m_ClippingThresProj < 0.0f)
3843 unsigned int batchIndx = 0;
3844 unsigned int inputIndx = 1;
3845 uint32_t timeStep = 1;
3846 unsigned int timeIndx = 1;
3848 if (m_Parameters.m_TimeMajor)
3859 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
3860 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
3861 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
3862 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
3865 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 3, (timeStep * n_batch * n_input),
3866 descriptorName +
" input_0");
3868 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
3869 descriptorName +
" input_1");
3871 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
3872 descriptorName +
" input_2");
3875 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 3, (timeStep * n_batch * n_output),
3876 descriptorName +
" output_0");
3879 if ( m_InputToInputWeights )
3881 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
3882 (n_cell * n_input),
"InputLayerNormWeights");
3885 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
3886 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
3887 (n_cell * n_input),
"InputToForgetWeights");
3889 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
3890 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
3891 (n_cell * n_input),
"InputToCellWeights");
3893 if ( m_RecurrentToInputWeights )
3895 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
3896 (n_cell * n_output),
"RecurrentToInputWeights");
3899 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
3900 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
3901 (n_cell * n_output),
"RecurrentToForgetWeights");
3903 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
3904 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
3905 (n_cell * n_output),
"RecurrentToCellWeights");
3909 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
3910 !m_Parameters.m_CifgEnabled) ||
3911 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3912 m_Parameters.m_CifgEnabled));
3913 if (!cifg_weights_all_or_none)
3916 "RecurrentToInputWeights must either both be present (regular LSTM) " 3917 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 3921 if ( m_CellToInputWeights )
3923 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
3924 n_cell,
"CellToInputWeights");
3926 if ( m_CellToForgetWeights )
3928 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
3929 n_cell,
"CellToForgetWeights");
3931 if ( m_CellToOutputWeights )
3933 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
3934 n_cell,
"CellToOutputWeights");
3938 bool peephole_weights_all_or_none =
3939 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3940 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3941 || ( !m_CellToInputWeights && !m_CellToForgetWeights
3942 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3943 if (!peephole_weights_all_or_none)
3949 if (m_Parameters.m_CifgEnabled)
3951 if (m_InputGateBias)
3958 if (!m_InputGateBias)
3961 "must be present.");
3963 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
3964 n_cell,
"InputGateBias");
3967 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
3968 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
3970 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
3971 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
3973 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
3974 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
3976 if (m_ProjectionWeights)
3978 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
3979 (n_cell * n_output),
"ProjectionWeights");
3981 if (m_ProjectionBias)
3983 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
3990 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
3991 !m_Parameters.m_ProjectionEnabled)
3992 || (m_ProjectionWeights && !m_ProjectionBias &&
3993 m_Parameters.m_ProjectionEnabled)
3994 || (m_ProjectionWeights && m_ProjectionBias &&
3995 m_Parameters.m_ProjectionEnabled));
3996 if (!projecton_tensors_consistent)
4005 if (m_InputLayerNormWeights)
4007 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
4009 if (m_ForgetLayerNormWeights)
4011 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
4013 if (m_CellLayerNormWeights)
4015 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
4017 if (m_OutputLayerNormWeights)
4019 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
4022 if (m_Parameters.m_LayerNormEnabled)
4024 if (!m_Parameters.m_CifgEnabled)
4026 if (!m_InputLayerNormWeights)
4029 "disabled but InputLayerNormWeights are not present");
4031 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
4032 1, n_cell,
"InputLayerNormWeights");
4034 else if (m_InputLayerNormWeights)
4040 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
4041 "ForgetLayerNormWeights");
4042 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
4044 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
4045 "OutputLayerNormWeights");
4046 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
4048 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
4049 "CellLayerNormWeights");
4050 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
4052 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
4055 "normalisation weights are present.");
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
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