16 #include <boost/format.hpp> 17 #include <boost/numeric/conversion/cast.hpp> 27 switch (inputDataType)
29 case DataType::Float16:
30 return DataType::Float16;
32 case DataType::Float32:
33 return DataType::Float32;
34 case DataType::QAsymmS8:
35 return DataType::Signed32;
36 case DataType::QAsymmU8:
37 return DataType::Signed32;
38 case DataType::QSymmS8:
39 return DataType::Signed32;
40 case DataType::QSymmS16:
41 return DataType::Signed32;
44 return DataType::Float32;
54 std::string to_string(T value)
56 std::ostringstream os;
62 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
67 paramName +
" parameter must be set.");
72 void ValidateTensorShapesMatch(
const TensorInfo& first,
74 std::string
const& descName,
75 std::string
const& firstName,
76 std::string
const& secondName)
81 + firstName +
" & " + secondName +
" must have identical shapes");
86 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
91 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
97 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
102 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
108 void ValidateTensorNumDimensions(
const TensorInfo& tensor,
109 std::string
const& descName,
110 unsigned int numDimensions,
111 std::string
const& tensorName)
117 tensorName +
" tensor.");
122 void ValidateTensorNumElements(
const TensorInfo& tensor,
123 std::string
const& descName,
124 unsigned int numElements,
125 std::string
const& tensorName)
131 tensorName +
" tensor.");
136 void ValidateTensorNumDimNumElem(
const TensorInfo& tensorInfo,
137 unsigned int numDimension,
138 unsigned int numElements,
139 std::string
const& tensorName)
141 const std::string functionName{
"ValidateTensorNumDimNumElem"};
142 ValidateTensorNumDimensions(tensorInfo, functionName, numDimension, tensorName);
143 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
148 const std::string& descName, std::string
const& tensorName)
157 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
161 tensor.
GetDataType() != DataType::QuantizedSymm8PerAxis)
164 ": Expected data type which supports per-axis quantization scheme but got " +
171 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
173 const std::string& descName,
174 std::string
const& firstName,
175 std::string
const& secondName)
187 if (firstDataType != secondDataType)
190 " must be of the same quantized type, " +
198 " must have the same quantization space, " +
207 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
210 const std::string& descName)
213 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 215 constexpr
float tolerance = 0.000001f;
216 if (std::abs(biasScale - expectedScale) > tolerance)
219 std::stringstream msg;
220 msg << std::setprecision(10) << descName <<
": Expected " << expectedScale <<
221 " quantization scale for bias tensor (the product of the input and weight scales), but got " <<
239 if (weightScales.size() != biasScales.size())
241 std::stringstream msg;
242 msg << descName <<
": Expected matchhing number of per-axis quantization scales, but got different " 243 <<
"values: weights=" << weightScales.size() <<
", biases=" << biasScales.size();
247 for (
size_t i = 0ul; i < biasScales.size(); ++i)
250 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
262 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
263 unsigned int numExpected,
264 const std::string& descName,
265 const std::string& varName)
267 if (vec.empty() && numExpected > 0)
272 for (
unsigned int i = 0; i < numExpected; ++i)
282 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
285 std::string
const& descName,
286 std::string
const& firstName,
287 std::string
const& secondName)
294 + firstName +
" & " + secondName
295 +
" must have the same number of dimensions in order to be broadcasted");
298 std::vector<uint32_t> outputDims(numDims, 0u);
299 for (uint32_t i = 0; i < numDims; i++)
302 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
303 if (dimsNotEqual && dimsNotOne)
309 TensorShape broadcastShape =
TensorShape(boost::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
310 if (broadcastShape != output.
GetShape())
313 + firstName +
" & " + secondName
314 +
" does not match the output shape");
320 const std::vector<armnn::DataType>& supportedTypes,
321 std::string
const& descName)
323 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
324 if (iterator == supportedTypes.end())
331 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
333 std::string
const& descName,
334 std::string
const& firstName,
335 std::string
const& secondName)
340 " must have identical data types.");
345 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
347 std::string
const& descName,
348 std::string
const& firstName,
349 std::string
const& secondName)
354 " must have the same number of elements.");
358 void ValidateWeightDataType(
const TensorInfo& inputInfo,
360 const std::string& descName)
366 const std::vector<DataType> validTypes =
371 DataType::QuantizedSymm8PerAxis
375 ValidateDataTypes(weightInfo, validTypes, descName);
379 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
383 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
384 const std::string& descName,
385 const std::string& tensorName)
391 boost::format(
"%1%: Quantization dimension for per-axis quantization not set on tensor %2%.")
392 % descName % tensorName));
395 if (quantizationDim.
value() != 0)
398 boost::format(
"%1%: Quantization dimension for per-axis quantization expected to be 0 on tensor %2%, " 399 "but got: %3%") % descName % tensorName % quantizationDim.
value()));
403 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
404 const std::string& descName,
405 const std::string& tensorName)
408 if (quantizationOffset != 0)
411 boost::format(
"%1%: Quantization offset for per-axis quantization expected to be 0 on tensor %2%, " 412 "but got: %3%") % descName % tensorName % quantizationOffset));
416 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
420 const std::string& descName)
427 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
429 if (!canHavePerAxisQuantization)
432 boost::format(
"%1%: Per-axis quantization parameters set on tensor %2%, " 433 "but data type does not support per-axis quantization.") % descName %
"weight"));
437 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
438 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
439 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
447 boost::format(
"%1%: Per-axis quantization parameters not set on bias tensor, despite being set on " 448 "weight tensor.") % descName));
451 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
452 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
453 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
461 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 463 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
464 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
470 const std::string descriptorName{
"MemCopyQueueDescriptor"};
472 ValidateNumInputs(workloadInfo, descriptorName, 1);
473 ValidateNumOutputs(workloadInfo, descriptorName , 1);
478 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
479 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
484 boost::format(
"%1%: Number of inputs (%2%) does not match the number of outputs (%3%).") %
488 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
493 descriptorName % i));
499 descriptorName % i));
507 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
508 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
513 boost::format(
"Number of input infos (%1%) is not 1.")
521 boost::format(
"Number of input infos (%1%) does not match the number of output infos (%2%)")
531 boost::format(
"Number of elements for tensor input and output %1% does not match")
539 boost::format(
"Number of inputs (%1%) is not 1.")
546 boost::format(
"Number of inputs (%1%) does not match the number of outputs (%2%)")
550 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
567 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
568 ValidateNumOutputs(workloadInfo,
"MemSyncQueueDescriptor" , 1);
573 boost::format(
"Number of inputs (%1%) is not 1.")
580 boost::format(
"Number of outputs (%1%) is not 0.")
593 const std::string descriptorName{
"ActivationQueueDescriptor"};
595 ValidateNumInputs(workloadInfo, descriptorName, 1);
596 ValidateNumOutputs(workloadInfo, descriptorName, 1);
601 std::vector<DataType> supportedTypes =
611 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
612 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
613 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
618 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
620 ValidateNumInputs(workloadInfo, descriptorName, 1);
621 ValidateNumOutputs(workloadInfo, descriptorName, 1);
631 std::vector<DataType> supportedInputTypes =
642 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
644 auto inputShape = inputTensorInfo.
GetShape();
645 auto outputShape = outputTensorInfo.
GetShape();
650 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
653 if (inputShape.GetNumDimensions() == 1)
655 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
662 for (
unsigned int i = 0; i < unsignedAxis; ++i)
664 if (outputShape[i] != inputShape[i])
670 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
672 if (outputShape[i - 1] != inputShape[i])
682 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
684 ValidateNumInputs(workloadInfo, descriptorName, 1);
685 ValidateNumOutputs(workloadInfo, descriptorName, 1);
690 std::vector<DataType> supportedTypes =
700 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
701 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
702 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
707 const std::string descriptorName{
"SplitterQueueDescriptor"};
709 ValidateNumInputs(workloadInfo, descriptorName, 1);
712 std::vector<DataType> supportedTypes =
728 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
730 const std::string outputName =
"output_" + std::to_string(i);
731 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
742 descriptorName +
": Number of split windows " 743 "has to match number of workloadInfo.m_OutputTensorInfos. " 744 "Number of windows: " +
745 to_string(m_ViewOrigins.size()) +
746 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
751 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
758 "have the same dimensionality as the input tensor. " 759 "Window origin (index: " +
760 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
761 " dimensions, the input " 763 to_string(inputDims) +
" dimensions.");
765 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
771 "be smaller or equal than the size of the input in that coord.");
779 const std::string descriptorName{
"ConcatQueueDescriptor"};
781 ValidateNumOutputs(workloadInfo, descriptorName, 1);
801 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
806 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
814 descriptorName +
": Number of split windows " 815 "has to match number of workloadInfo.m_InputTensorInfos. " 816 "Number of windows: " +
817 to_string(m_ViewOrigins.size()) +
818 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
823 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
827 if (e.
m_Origin.size() != outputDims)
830 "have the same dimensionality as the output tensor. " 831 "Window origin (index: " +
832 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
833 " dimensions, the output " 835 to_string(outputDims) +
" dimensions.");
838 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
844 "be smaller or equal than the size of the output in that coord.");
850 std::vector<DataType> supportedTypes =
866 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
868 const std::string inputName =
"input_" + std::to_string(i);
869 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
875 const std::string descriptorName{
"StackQueueDescriptor"};
877 ValidateNumOutputs(workloadInfo, descriptorName, 1);
885 const TensorShape& inputShape = m_Parameters.m_InputShape;
904 "than the number of input dimensions.");
909 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
911 if (outputShape[i] != inputShape[i])
914 "match shape inferred from input tensor.");
918 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
921 "match shape inferred from input tensor.");
924 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
926 if (outputShape[i] != inputShape[i-1])
929 "match shape inferred from input tensor.");
939 std::vector<DataType> supportedTypes =
951 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
959 "input_" + std::to_string(i));
971 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
973 ValidateNumInputs(workloadInfo, descriptorName, 1);
974 ValidateNumOutputs(workloadInfo, descriptorName, 1);
979 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
986 ValidatePointer(m_Weight, descriptorName,
"weight");
988 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
989 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 2,
"weight");
991 if (m_Parameters.m_BiasEnabled)
993 ValidatePointer(m_Bias, descriptorName,
"bias");
996 const TensorInfo& biasTensorInfo = m_Bias->GetTensorInfo();
997 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1000 ValidateTensorNumDimensions(biasTensorInfo, descriptorName, 1,
"bias");
1004 std::vector<DataType> supportedTypes =
1014 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1022 "for BFloat16 input.");
1027 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1033 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1035 ValidateNumInputs(workloadInfo, descriptorName, 1);
1036 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1042 std::vector<DataType> supportedTypes =
1052 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1054 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1056 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1061 const std::string descriptorName{
"AdditionQueueDescriptor"};
1063 ValidateNumInputs(workloadInfo, descriptorName, 2);
1064 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1070 std::vector<DataType> supportedTypes =
1080 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1081 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1082 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1084 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1085 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1087 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1097 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1099 ValidateNumInputs(workloadInfo, descriptorName, 2);
1100 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1106 std::vector<DataType> supportedTypes =
1116 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1117 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1118 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1120 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1121 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1123 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1133 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1135 ValidateNumInputs(workloadInfo, descriptorName, 1);
1136 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1141 std::vector<DataType> supportedTypes =
1151 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1152 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1154 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1155 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1157 ValidatePointer(m_Mean, descriptorName,
"mean");
1158 ValidatePointer(m_Variance, descriptorName,
"variance");
1159 ValidatePointer(m_Beta, descriptorName,
"beta");
1160 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1162 const TensorInfo& mean = m_Mean->GetTensorInfo();
1163 const TensorInfo& variance = m_Variance->GetTensorInfo();
1164 const TensorInfo& beta = m_Beta->GetTensorInfo();
1165 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1167 ValidateTensorNumDimensions(mean, descriptorName, 1,
"mean");
1168 ValidateTensorNumDimensions(variance, descriptorName, 1,
"variance");
1169 ValidateTensorNumDimensions(beta, descriptorName, 1,
"beta");
1170 ValidateTensorNumDimensions(gamma, descriptorName, 1,
"gamma");
1172 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1173 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1174 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1179 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1181 ValidateNumInputs(workloadInfo, descriptorName, 1);
1182 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1187 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1188 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1190 ValidatePointer(m_Weight, descriptorName,
"weight");
1192 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1193 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1195 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1198 if (m_Parameters.m_BiasEnabled)
1200 ValidatePointer(m_Bias, descriptorName,
"bias");
1202 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1206 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1209 ValidatePerAxisQuantization(inputTensorInfo,
1212 optionalBiasTensorInfo,
1215 std::vector<DataType> supportedTypes =
1226 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1234 "for BFloat16 input.");
1239 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1245 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1247 ValidateNumInputs(workloadInfo, descriptorName, 1);
1248 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1253 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1254 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1256 ValidatePointer(m_Weight, descriptorName,
"weight");
1258 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1259 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1261 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1264 boost::str(boost::format(
"%1%: dilationX (provided %2%) and dilationY (provided %3%) " 1265 "cannot be smaller than 1.") % descriptorName %
1266 m_Parameters.m_DilationX % m_Parameters.m_DilationX));
1269 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1273 const unsigned int numWeightChannelMultiplier = weightTensorInfo.
GetShape()[0];
1274 const unsigned int numWeightInputChannels = weightTensorInfo.
GetShape()[1];
1275 const unsigned int numWeightOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1276 if (numWeightChannelMultiplier * numWeightInputChannels != numWeightOutputChannels)
1279 boost::str(boost::format(
"%1%: output_channels (provided %2%) should be " 1280 "equal to input_channels (provided %3%) multiplied by channel_multiplier " 1281 "(provided %4%).") % descriptorName % numWeightOutputChannels %
1282 numWeightInputChannels % numWeightChannelMultiplier));
1285 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1288 if (m_Parameters.m_BiasEnabled)
1290 ValidatePointer(m_Bias, descriptorName,
"bias");
1292 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1295 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1298 ValidatePerAxisQuantization(inputTensorInfo,
1301 optionalBiasTensorInfo,
1304 std::vector<DataType> supportedTypes =
1314 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1315 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1320 const std::string descriptorName{
"PermuteQueueDescriptor"};
1322 ValidateNumInputs(workloadInfo, descriptorName, 1);
1323 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1330 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
1331 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
1333 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1335 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1338 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1339 "must match dst dimension " + to_string(mapping[i]) +
1340 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1344 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1349 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1351 ValidateNumInputs(workloadInfo, descriptorName, 1);
1352 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1357 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1358 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1360 std::vector<DataType> supportedTypes =
1370 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1371 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1376 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1378 ValidateNumInputs(workloadInfo, descriptorName, 1);
1379 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1384 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1385 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1387 std::vector<DataType> supportedTypes =
1397 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1398 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1401 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1402 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1403 if (inputBatchSize != outputBatchSize)
1406 boost::str(boost::format(
"%1%: Input batch size (%2%) " 1407 "does not match output batch size (%3%)") %
1408 descriptorName % inputBatchSize % outputBatchSize));
1414 if (inputChannelCount != outputChannelCount)
1417 boost::str(boost::format(
"%1%: Input channel count (%2%) " 1418 "does not match output channel count (%3%)") %
1419 descriptorName % inputChannelCount % outputChannelCount));
1425 const std::string descriptorName{
"ResizeQueueDescriptor"};
1427 ValidateNumInputs(workloadInfo, descriptorName, 1);
1428 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1433 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1434 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1436 std::vector<DataType> supportedTypes =
1446 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1447 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1450 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1451 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1452 if (inputBatchSize != outputBatchSize)
1455 boost::str(boost::format(
"%1%: Input batch size (%2%) " 1456 "does not match output batch size (%3%)") %
1457 descriptorName % inputBatchSize % outputBatchSize));
1463 if (inputChannelCount != outputChannelCount)
1466 boost::str(boost::format(
"%1%: Input channel count (%2%) " 1467 "does not match output channel count (%3%)") %
1468 descriptorName % inputChannelCount % outputChannelCount));
1474 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1476 ValidateNumInputs(workloadInfo, descriptorName, 1);
1477 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1482 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1483 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1485 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1487 if (m_Parameters.m_Min > m_Parameters.m_Max)
1495 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1497 ValidateNumInputs(workloadInfo, descriptorName, 1);
1498 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1508 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1511 std::vector<DataType> supportedTypes =
1518 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1519 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1524 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1526 ValidateNumInputs(workloadInfo, descriptorName, 1);
1527 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1537 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1540 std::vector<DataType> supportedTypes =
1550 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1551 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1556 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1558 ValidateNumInputs(workloadInfo, descriptorName, 1);
1559 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1564 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1566 std::vector<DataType> supportedTypes =
1573 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1574 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1579 const std::string descriptorName{
"ConstantQueueDescriptor"};
1581 ValidateNumInputs(workloadInfo, descriptorName, 0);
1582 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1590 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1593 std::vector<DataType> supportedTypes =
1605 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1610 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1612 ValidateNumInputs(workloadInfo, descriptorName, 1);
1613 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1618 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1621 std::vector<DataType> supportedTypes =
1632 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1633 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1638 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1640 ValidateNumInputs(workloadInfo, descriptorName, 1);
1641 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1646 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1647 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1649 if (m_Parameters.m_BlockShape.size() != 2)
1654 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1657 "dimensions as Block Shape.");
1662 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1663 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1667 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1668 widthPad.first + widthPad.second;
1669 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1670 heightPad.first + heightPad.second;
1672 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1674 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1676 if (numOutputElements != numInputElements)
1679 to_string(numInputElements) +
" after padding but output tensor has " +
1680 to_string(numOutputElements) +
" elements.");
1683 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1686 "divisible by Block Shape in all spatial dimensions");
1689 std::vector<DataType> supportedTypes =
1699 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1700 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1705 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1707 ValidateNumInputs(workloadInfo, descriptorName, 1);
1708 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1713 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1714 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1716 std::vector<DataType> supportedTypes =
1726 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1727 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1729 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1731 if (m_Parameters.m_BlockSize == 0)
1737 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1742 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1745 "by block size in all spatial dimensions");
1749 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1752 "must be divisible by the square of block size." );
1758 const std::string descriptorName{
"FloorQueueDescriptor"};
1760 ValidateNumInputs(workloadInfo, descriptorName, 1);
1761 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1766 std::vector<DataType> supportedTypes =
1774 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1776 if (inputTensorInfo != outputTensorInfo)
1786 const std::string descriptorName{
"LstmQueueDescriptor"};
1798 std::vector<DataType> supportedTypes =
1807 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1816 "input_" + std::to_string(i));
1823 "LstmQueueDescriptor",
1825 "output_" + std::to_string(i));
1831 if (m_Parameters.m_ClippingThresCell < 0.0f)
1835 if (m_Parameters.m_ClippingThresProj < 0.0f)
1844 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
1845 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
1846 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
1847 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
1850 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
1851 descriptorName +
" input_0");
1853 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
1854 descriptorName +
" input_1");
1856 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
1857 descriptorName +
" input_2");
1859 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
1860 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
1861 descriptorName +
" output_0");
1864 descriptorName +
" output_1");
1867 descriptorName +
" output_2");
1870 descriptorName +
" output_3");
1874 if ( m_InputToInputWeights )
1876 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
1877 (n_cell * n_input),
"InputLayerNormWeights");
1880 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
1881 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
1882 (n_cell * n_input),
"InputToForgetWeights");
1884 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
1885 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
1886 (n_cell * n_input),
"InputToCellWeights");
1888 if ( m_RecurrentToInputWeights )
1890 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
1891 (n_cell * n_output),
"RecurrentToInputWeights");
1894 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
1895 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
1896 (n_cell * n_output),
"RecurrentToForgetWeights");
1898 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
1899 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
1900 (n_cell * n_output),
"RecurrentToCellWeights");
1904 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
1905 !m_Parameters.m_CifgEnabled) ||
1906 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
1907 m_Parameters.m_CifgEnabled));
1908 if (!cifg_weights_all_or_none)
1911 "RecurrentToInputWeights must either both be present (regular LSTM) " 1912 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 1916 if ( m_CellToInputWeights )
1918 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
1919 n_cell,
"CellToInputWeights");
1921 if ( m_CellToForgetWeights )
1923 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
1924 n_cell,
"CellToForgetWeights");
1926 if ( m_CellToOutputWeights )
1928 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
1929 n_cell,
"CellToOutputWeights");
1933 bool peephole_weights_all_or_none =
1934 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
1935 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
1936 || ( !m_CellToInputWeights && !m_CellToForgetWeights
1937 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
1938 if (!peephole_weights_all_or_none)
1944 if (m_Parameters.m_CifgEnabled)
1946 if (m_InputGateBias)
1953 if (!m_InputGateBias)
1956 "must be present.");
1958 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
1959 n_cell,
"InputGateBias");
1962 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
1963 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
1965 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
1966 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
1968 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
1969 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
1971 if (m_ProjectionWeights)
1973 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
1974 (n_cell * n_output),
"ProjectionWeights");
1976 if (m_ProjectionBias)
1978 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
1985 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
1986 !m_Parameters.m_ProjectionEnabled)
1987 || (m_ProjectionWeights && !m_ProjectionBias &&
1988 m_Parameters.m_ProjectionEnabled)
1989 || (m_ProjectionWeights && m_ProjectionBias &&
1990 m_Parameters.m_ProjectionEnabled));
1991 if (!projecton_tensors_consistent)
2000 if (m_InputLayerNormWeights)
2002 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2004 if (m_ForgetLayerNormWeights)
2006 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2008 if (m_CellLayerNormWeights)
2010 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2012 if (m_OutputLayerNormWeights)
2014 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2017 if (m_Parameters.m_LayerNormEnabled)
2019 if (!m_Parameters.m_CifgEnabled)
2021 if (!m_InputLayerNormWeights)
2024 "disabled but InputLayerNormWeights are not present");
2026 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2027 1, n_cell,
"InputLayerNormWeights");
2029 else if (m_InputLayerNormWeights)
2035 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2036 "ForgetLayerNormWeights");
2037 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2039 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2040 "OutputLayerNormWeights");
2041 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2043 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2044 "CellLayerNormWeights");
2045 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2047 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2050 "normalisation weights are present.");
2056 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2058 ValidateNumInputs(workloadInfo, descriptorName, 1);
2059 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2074 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2079 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2081 ValidateNumInputs(workloadInfo, descriptorName, 1);
2082 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2097 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2102 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2104 ValidateNumInputs(workloadInfo, descriptorName, 1);
2105 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2120 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2125 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2127 ValidateNumInputs(workloadInfo, descriptorName, 1);
2128 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2143 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2148 const std::string descriptorName{
"DivisionQueueDescriptor"};
2150 ValidateNumInputs(workloadInfo, descriptorName, 2);
2151 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2157 std::vector<DataType> supportedTypes =
2167 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2168 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2169 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2171 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2181 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2183 ValidateNumInputs(workloadInfo, descriptorName, 2);
2184 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2190 std::vector<DataType> supportedTypes =
2200 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2201 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2202 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2204 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2214 const std::string descriptorName{
"MaximumQueueDescriptor"};
2216 ValidateNumInputs(workloadInfo, descriptorName, 2);
2217 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2223 std::vector<DataType> supportedTypes =
2234 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2235 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2236 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2238 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2248 const std::string descriptorName{
"MeanQueueDescriptor"};
2250 ValidateNumInputs(workloadInfo, descriptorName, 1);
2251 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2256 std::vector<DataType> supportedTypes =
2268 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2269 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2271 if (m_Parameters.m_KeepDims)
2273 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2275 else if (m_Parameters.m_Axis.empty())
2277 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2281 unsigned int outputDim =
2283 ValidateTensorNumDimensions(outputTensorInfo,
2285 outputDim > 0 ? outputDim : 1,
2292 const std::string descriptorName{
"PadQueueDescriptor"};
2294 ValidateNumInputs(workloadInfo, descriptorName, 1);
2295 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2301 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2306 "as there are dimensions in the input tensor that is " +
2308 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2314 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2316 ValidateNumInputs(workloadInfo, descriptorName, 1);
2317 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2322 std::vector<DataType> supportedTypes =
2333 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2343 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2345 ValidateNumInputs(workloadInfo, descriptorName, 1);
2346 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2351 std::vector<DataType> supportedTypes =
2361 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2362 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2367 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2369 ValidateNumInputs(workloadInfo, descriptorName, 1);
2370 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2375 std::vector<DataType> supportedTypes =
2385 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2386 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2388 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2397 if (m_Parameters.m_Begin.size() != rank)
2402 if (m_Parameters.m_End.size() != rank)
2407 if (m_Parameters.m_Stride.size() != rank)
2413 for (
auto& stride : m_Parameters.m_Stride)
2424 const std::string descriptorName{
"MinimumQueueDescriptor"};
2426 ValidateNumInputs(workloadInfo, descriptorName, 2);
2427 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2433 std::vector<DataType> supportedTypes =
2444 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2445 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2446 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2448 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2458 const std::string descriptorName{
"DebugQueueDescriptor"};
2460 ValidateNumInputs(workloadInfo, descriptorName, 1);
2461 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2466 const std::string descriptorName{
"EqualQueueDescriptor"};
2468 ValidateNumInputs(workloadInfo, descriptorName, 2);
2469 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2475 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2490 const std::string descriptorName{
"GreaterQueueDescriptor"};
2492 ValidateNumInputs(workloadInfo, descriptorName, 2);
2493 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2499 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2514 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2516 ValidateNumInputs(workloadInfo, descriptorName, 1);
2517 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2522 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2524 std::vector<DataType> supportedTypes =
2534 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2535 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2540 const std::string descriptorName{
"GatherQueueDescriptor"};
2542 ValidateNumInputs(workloadInfo, descriptorName, 2);
2543 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2554 std::vector<DataType> supportedTypes =
2564 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2566 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2569 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2574 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2576 ValidateNumInputs(workloadInfo, descriptorName, 2);
2584 if (m_Anchors ==
nullptr)
2598 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2599 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2600 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2602 const std::vector<DataType> supportedInputTypes =
2612 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2613 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2614 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2616 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2617 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2618 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2619 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2622 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2623 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2624 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2625 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2627 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2630 "must be positive and less than or equal to 1.");
2633 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2636 "should be equal to number of classes + 1.");
2642 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2644 ValidateNumInputs(workloadInfo, descriptorName, 1);
2645 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2655 std::vector<DataType> supportedTypes =
2662 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2667 const std::string& descriptorName{
"MergeQueueDescriptor"};
2669 ValidateNumInputs(workloadInfo, descriptorName, 2);
2670 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2676 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2677 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2679 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2680 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2685 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2687 ValidateNumInputs(workloadInfo, descriptorName, 2);
2688 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2696 std::vector<DataType> supportedTypes =
2705 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2706 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2708 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2709 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2711 ValidateTensorShapesMatch(inputTensorInfo0,
2717 ValidateTensorShapesMatch(inputTensorInfo0,
2731 const std::string& descriptorName{
"PreluQueueDescriptor"};
2733 ValidateNumInputs(workloadInfo, descriptorName, 2);
2734 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2740 std::vector<DataType> supportedTypes
2750 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2751 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2753 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2755 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2756 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2758 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2768 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2770 ValidateNumInputs(workloadInfo, descriptorName, 1);
2771 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2776 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2777 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2779 ValidatePointer(m_Weight, descriptorName,
"weight");
2781 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2782 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2784 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2787 if (m_Parameters.m_BiasEnabled)
2789 ValidatePointer(m_Bias, descriptorName,
"bias");
2791 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
2795 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2798 ValidatePerAxisQuantization(inputTensorInfo,
2801 optionalBiasTensorInfo,
2804 std::vector<DataType> supportedTypes =
2814 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2815 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2820 const std::string descriptorName{
"TransposeQueueDescriptor"};
2822 ValidateNumInputs(workloadInfo, descriptorName, 1);
2823 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2830 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
2831 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
2833 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
2835 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
2838 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
2839 "must match dst dimension " + to_string(i) +
2840 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
2844 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2849 const std::string descriptorName{
"QLstmQueueDescriptor"};
2852 ValidateNumInputs(workloadInfo, descriptorName, 3);
2853 ValidateNumOutputs(workloadInfo, descriptorName, 3);
2865 std::vector<DataType> inputOutputSupportedTypes =
2870 std::vector<DataType> cellStateSupportedTypes =
2875 std::vector<DataType> weightsSupportedTypes =
2880 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
2885 std::vector<DataType> biasSupportedTypes =
2891 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
2892 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
2893 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
2895 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
2896 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
2897 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
2900 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
2901 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
2902 "outputStateIn",
"outputStateOut");
2903 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
2906 const uint32_t numBatches = inputInfo.GetShape()[0];
2907 const uint32_t inputSize = inputInfo.GetShape()[1];
2908 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
2909 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
2912 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
2913 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
2914 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
2916 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
2917 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
2918 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
2921 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
2922 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
2923 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
2925 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
2926 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
2927 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
2929 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
2930 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
2931 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
2933 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
2934 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
2935 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
2936 " RecurrentToForgetWeights");
2938 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
2939 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
2940 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
2942 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
2943 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
2944 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
2947 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
2949 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
2950 "inputToForgetWeights",
"inputToCellWeights");
2951 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
2952 "inputToForgetWeights",
"inputToOutputWeights");
2954 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
2955 "inputToForgetWeights",
"recurrentToForgeteights");
2956 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
2957 "inputToForgetWeights",
"recurrentToCellWeights");
2958 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
2959 "inputToForgetWeights",
"recurrentToOutputWeights");
2962 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
2963 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
2964 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
2966 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
2967 auto cellBiasInfo = m_CellBias->GetTensorInfo();
2968 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
2970 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
2971 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
2972 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
2975 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
2977 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
2978 "forgetGateBias",
"cellBias");
2979 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
2980 "forgetGateBias",
"outputGateBias");
2983 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
2984 !m_Parameters.m_CifgEnabled) ||
2985 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
2986 !m_InputGateBias && m_Parameters.m_CifgEnabled));
2988 if (!allCifgParamsPresentOrNot)
2991 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 2992 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 2993 "set appropriately.");
2996 if (!m_Parameters.m_CifgEnabled)
2999 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3000 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3002 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3003 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3004 " RecurrentToInputWeights");
3006 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3007 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3010 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3011 "inputToForgetWeights",
"inputToInputWeights");
3012 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3013 "inputToForgetWeights",
"recurrentToInputWeights");
3014 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3015 "forgetGateBias",
"inputGateBias");
3019 bool allPeepholeWeightsPresentOrNot =
3020 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3021 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3022 || (!m_CellToInputWeights && !m_CellToForgetWeights
3023 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3025 if (!allPeepholeWeightsPresentOrNot)
3028 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3029 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3030 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3034 if (m_Parameters.m_PeepholeEnabled)
3036 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3037 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3038 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3040 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3041 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3042 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3043 "cellToForgetWeight",
"cellToOutputWeights");
3045 if (!m_Parameters.m_CifgEnabled)
3047 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3048 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3049 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3050 "cellToForgetWeights",
"cellToInputWeights");
3055 bool allLayerNormWeightsPresentOrNot =
3056 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3057 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3058 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3059 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3061 if (!allLayerNormWeightsPresentOrNot)
3064 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3065 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3066 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3067 "only be present when Layer Norm is enabled and CIFG is disabled. " 3068 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3071 if (m_Parameters.m_LayerNormEnabled)
3073 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3074 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3075 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3077 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3078 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3079 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3080 "forgetLayerNormWeights",
"cellLayerNormWeights");
3082 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3083 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3084 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3085 "forgetLayerNormWeights",
"outputLayerNormWeights");
3087 if (!m_Parameters.m_CifgEnabled)
3089 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3090 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3091 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3092 "forgetLayerNormWeights",
"inputLayerNormWeights");
3097 bool correctProjectionTensorsPresent =
3098 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3099 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3100 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3102 if (!correctProjectionTensorsPresent)
3105 ": If projection is enabled, ProjectionWeights should be present and " 3106 "ProjectionBias is optional. If projection is disabled, neither " 3107 "ProjectionWeights nor ProjectionBias should be present.");
3110 if (m_Parameters.m_ProjectionEnabled)
3112 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3113 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3114 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3116 if (m_ProjectionBias)
3118 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3119 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3120 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3124 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3125 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3127 ": If projection is disabled, output quantization info (scale, offset) " 3128 "should match HiddenStateScale and HiddenStateZeroPoint.");
3135 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3138 ValidateNumInputs(workloadInfo, descriptorName, 3);
3139 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3149 std::vector<DataType> inputOutputSupportedTypes =
3154 std::vector<DataType> cellStateSupportedTypes =
3159 std::vector<DataType> weightsSupportedTypes =
3164 std::vector<DataType> biasSupportedTypes =
3170 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3171 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3172 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3174 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3175 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3178 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3179 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3180 "outputStateIn",
"outputStateOut");
3181 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3184 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3185 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3186 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3189 const uint32_t numBatches = inputInfo.GetShape()[0];
3190 const uint32_t inputSize = inputInfo.GetShape()[1];
3191 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3194 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3195 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3196 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3197 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3198 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3201 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3202 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3203 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3205 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3206 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3207 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3209 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3210 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3211 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3213 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3214 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3215 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3217 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3218 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3219 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3221 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3222 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3223 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3224 " RecurrentToForgetWeights");
3226 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3227 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3228 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3230 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3231 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3232 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3235 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3237 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3238 "inputToInputWeights",
"inputToForgetWeights");
3239 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3240 "inputToInputWeights",
"inputToCellWeights");
3241 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3242 "inputToInputWeights",
"inputToOutputWeights");
3244 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3245 "inputToInputWeights",
"recurrentToInputWeights");
3246 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3247 "inputToInputWeights",
"recurrentToForgeteights");
3248 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3249 "inputToInputWeights",
"recurrentToCellWeights");
3250 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3251 "inputToInputWeights",
"recurrentToOutputWeights");
3254 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3255 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3256 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3257 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3258 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3259 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3261 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3262 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3263 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3264 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3265 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3266 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3267 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3268 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3271 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3272 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3273 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3275 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3276 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3277 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3279 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3280 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3281 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3283 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3284 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3285 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3288 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3290 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3291 "inputGateBias",
"forgetGateBias");
3292 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3293 "inputGateBias",
"cellBias");
3294 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3295 "inputGateBias",
"outputGateBias");
3298 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3299 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3300 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3301 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3306 const std::string descriptorName{
"AbsQueueDescriptor"};
3308 ValidateNumInputs(workloadInfo, descriptorName, 1);
3309 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3314 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3316 std::vector<DataType> supportedTypes =
3327 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3328 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3333 const std::string descriptorName{
"SliceQueueDescriptor"};
3335 ValidateNumInputs(workloadInfo, descriptorName, 1);
3336 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3341 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3349 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3352 if (m_Parameters.m_Begin.size() != rank)
3355 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3357 if (m_Parameters.m_Size.size() != rank)
3360 ": Length of size descriptor must equal rank " + std::to_string(rank));
3365 for (
unsigned int i = 0u; i < rank; ++i)
3367 if (m_Parameters.m_Size[i] != outputShape[i])
3376 for(
unsigned int i = 0u; i < rank; ++i)
3378 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3381 std::to_string(i) +
" exceeds input size.");
3388 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3390 ValidateNumInputs(workloadInfo, descriptorName, 1);
3391 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3396 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3397 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3399 std::vector<DataType> supportedTypes =
3409 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3410 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3412 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3414 if (m_Parameters.m_BlockSize == 0)
3420 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3425 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3428 "must be divisible by block size.");
3432 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3435 "must be divisible by the square of block size." );
3441 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3443 ValidateNumInputs(workloadInfo, descriptorName, 2);
3444 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3450 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3465 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3467 ValidateNumInputs(workloadInfo, descriptorName, 1);
3468 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3473 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3475 std::vector<DataType> supportedTypes =
3486 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3487 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool HasPerAxisQuantization() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
Optional< unsigned int > GetQuantizationDim() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32)
void ValidateInputsOutputs(const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const
Copyright (c) 2020 ARM Limited.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< float > GetQuantizationScales() const
bool HasMultipleQuantizationScales() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetHeightIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
constexpr const char * GetDataTypeName(DataType dataType)
constexpr bool IsQuantized8BitType(DataType dataType)
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_InputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_NO_DEPRECATE_WARN_END
void Validate(const WorkloadInfo &workloadInfo) const
#define ARMNN_ASSERT_MSG(COND, MSG)
void Validate(const WorkloadInfo &workloadInfo) const
int32_t GetQuantizationOffset() const
float GetQuantizationScale() const
Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout...
DataType GetDataType() const
bool has_value() const noexcept
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
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
std::vector< TensorInfo > m_OutputTensorInfos
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)
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
std::vector< ITensorHandle * > m_Outputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
Contains information about inputs and outputs to a layer.
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< ITensorHandle * > m_Inputs
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumDimensions() const
unsigned int GetChannelsIndex() const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumElements() const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< unsigned int > m_Origin