20 #include <fmt/format.h> 30 switch (inputDataType)
32 case DataType::Float16:
33 return DataType::Float16;
35 case DataType::Float32:
36 return DataType::Float32;
37 case DataType::QAsymmS8:
38 return DataType::Signed32;
39 case DataType::QAsymmU8:
40 return DataType::Signed32;
41 case DataType::QSymmS8:
42 return DataType::Signed32;
43 case DataType::QSymmS16:
44 return DataType::Signed32;
47 return DataType::Float32;
57 std::string to_string(T value)
59 std::ostringstream os;
65 void ValidatePointer(
const void* ptr, std::string
const& descName, std::string
const& paramName)
70 paramName +
" parameter must be set.");
75 void ValidateTensorShapesMatch(
const TensorInfo& first,
77 std::string
const& descName,
78 std::string
const& firstName,
79 std::string
const& secondName)
84 + firstName +
" & " + secondName +
" must have identical shapes");
89 void ValidateNumInputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
94 ": Requires exactly " + to_string(expectedSize) +
"input(s). " +
100 void ValidateNumOutputs(
const WorkloadInfo& workloadInfo, std::string
const& descName,
const unsigned int expectedSize)
105 ": Requires exactly " + to_string(expectedSize) +
" output(s). " +
113 void ValidateTensorNumElements(
const TensorInfo& tensor,
114 std::string
const& descName,
115 unsigned int numElements,
116 std::string
const& tensorName)
122 tensorName +
" tensor.");
128 const std::string& descName, std::string
const& tensorName)
137 void ValidPerAxisQuantizedDataType(
const TensorInfo& tensor,
const std::string& descName,
const std::string& tensorName)
142 ": Expected data type which supports per-axis quantization scheme but got " +
148 void ValidateTensorQuantizationSpace(
const TensorInfo& first,
150 const std::string& descName,
151 std::string
const& firstName,
152 std::string
const& secondName)
164 if (firstDataType != secondDataType)
167 " must be of the same quantized type, " +
175 " must have the same quantization space, " +
184 void ValidateBiasTensorQuantization(
const TensorInfo& biasTensor,
187 const std::string& descName)
190 auto VerifyBiasQuantizationScale = [&descName](
float biasScale,
float expectedScale) ->
void 192 constexpr
float tolerance = 0.0001f;
193 if (std::abs(biasScale - expectedScale) > tolerance)
196 ARMNN_LOG(
warning) << std::setprecision(6) << descName <<
": Expected " << expectedScale <<
197 " for bias quantization scale (product of input and weight scales), but got " <<
198 biasScale <<
". Using scale provided.";
214 if (weightScales.size() != biasScales.size())
216 std::stringstream msg;
217 msg << descName <<
": Expected matching number of per-axis quantization scales for weights and bias, " 218 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
219 <<
", biases=" << biasScales.size();
223 for (
size_t i = 0ul; i < biasScales.size(); ++i)
226 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
238 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
239 unsigned int numExpected,
240 const std::string& descName,
241 const std::string& varName)
243 if (vec.empty() && numExpected > 0)
248 for (
unsigned int i = 0; i < numExpected; ++i)
258 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
261 std::string
const& descName,
262 std::string
const& firstName,
263 std::string
const& secondName)
270 + firstName +
" & " + secondName
271 +
" must have the same number of dimensions in order to be broadcasted");
274 std::vector<uint32_t> outputDims(numDims, 0u);
275 for (uint32_t i = 0; i < numDims; i++)
278 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
279 if (dimsNotEqual && dimsNotOne)
285 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
286 if (broadcastShape != output.
GetShape())
289 + firstName +
" & " + secondName
290 +
" does not match the output shape");
296 const std::vector<armnn::DataType>& supportedTypes,
297 std::string
const& descName)
299 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
300 if (iterator == supportedTypes.end())
307 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
309 std::string
const& descName,
310 std::string
const& firstName,
311 std::string
const& secondName)
316 " must have identical data types.");
321 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
323 std::string
const& descName,
324 std::string
const& firstName,
325 std::string
const& secondName)
330 " must have the same number of elements.");
334 void ValidateWeightDataType(
const TensorInfo& inputInfo,
336 const std::string& descName)
341 const std::vector<DataType> validTypes =
348 ValidateDataTypes(weightInfo, validTypes, descName);
352 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
356 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
357 const std::string& descName,
358 const std::string& tensorName)
364 "not set on tensor {1}.", descName, tensorName));
368 void ValidatePerAxisQuantizationOffset(
const TensorInfo& tensorInfo,
369 const std::string& descName,
370 const std::string& tensorName)
373 if (quantizationOffset != 0)
376 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
377 descName, tensorName, quantizationOffset));
381 void ValidatePerAxisQuantization(
const TensorInfo& inputInfo,
385 const std::string& descName)
392 const bool canHavePerAxisQuantization = (
IsQuantized8BitType(inputDataType)) && inputDataType == outputDataType;
394 if (!canHavePerAxisQuantization)
397 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 398 "per-axis quantization.", descName,
"weight"));
402 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
403 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
404 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
412 "{}: Per-axis quantization parameters not set on bias tensor, " 413 "despite being set on weight tensor.", descName));
416 ValidateTensorDataType(biasInfo, DataType::Signed32, descName,
"bias");
417 ValidatePerAxisQuantizationDimension(biasInfo, descName,
"bias");
418 ValidatePerAxisQuantizationOffset(biasInfo, descName,
"bias");
427 std::string
const& descName,
428 unsigned int numDimensions,
429 std::string
const& tensorName)
const 436 unsigned int squeezedDims = 0;
445 if (tensor.
GetNumDimensions() < numDimensions || squeezedDims > numDimensions)
449 tensorName +
" tensor.");
458 tensorName +
" tensor.");
465 unsigned int numDimension,
466 unsigned int numElements,
467 std::string
const& tensorName)
const 469 const std::string functionName{
"ValidateTensorNumDimNumElem"};
471 ValidateTensorNumElements(tensorInfo, functionName, numElements, tensorName);
476 unsigned int numExpectedIn,
unsigned int numExpectedOut)
const 478 ValidateTensors(
m_Inputs, numExpectedIn, descName,
"input");
479 ValidateTensors(
m_Outputs, numExpectedOut, descName,
"output");
485 const std::string descriptorName{
"MapQueueDescriptor"};
487 ValidateNumInputs(workloadInfo, descriptorName, 1);
488 ValidateNumOutputs(workloadInfo, descriptorName, 0);
490 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
495 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
503 const std::string descriptorName{
"UnmapQueueDescriptor"};
505 ValidateNumInputs(workloadInfo, descriptorName, 1);
506 ValidateNumOutputs(workloadInfo, descriptorName, 0);
508 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
513 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
521 const std::string descriptorName{
"MemCopyQueueDescriptor"};
523 ValidateNumInputs(workloadInfo, descriptorName, 1);
524 ValidateNumOutputs(workloadInfo, descriptorName , 1);
529 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
530 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
535 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
539 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
544 "{0}: Invalid NULL input {1}.", descriptorName, i));
557 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
558 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
570 "Number of input infos ({0}) does not match the number of output infos ({1})",
580 "Number of elements for tensor input and output {} does not match", i ));
592 "Number of inputs ({0}) does not match the number of outputs ({1})",
596 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
613 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
634 const std::string descriptorName{
"ActivationQueueDescriptor"};
636 ValidateNumInputs(workloadInfo, descriptorName, 1);
637 ValidateNumOutputs(workloadInfo, descriptorName, 1);
642 std::vector<DataType> supportedTypes =
652 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
653 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
654 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
659 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
661 ValidateNumInputs(workloadInfo, descriptorName, 1);
662 ValidateNumOutputs(workloadInfo, descriptorName, 1);
673 std::vector<DataType> supportedInputTypes =
685 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
687 auto inputShape = inputTensorInfo.
GetShape();
688 auto outputShape = outputTensorInfo.
GetShape();
693 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
696 if (inputShape.GetNumDimensions() == 1)
698 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
705 for (
unsigned int i = 0; i < unsignedAxis; ++i)
707 if (outputShape[i] != inputShape[i])
713 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
715 if (outputShape[i - 1] != inputShape[i])
725 const std::string descriptorName{
"CastQueueDescriptor"};
727 ValidateNumInputs(workloadInfo, descriptorName, 1);
728 ValidateNumOutputs(workloadInfo, descriptorName, 1);
733 std::vector<DataType> supportedTypes =
746 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
747 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
752 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
754 ValidateNumInputs(workloadInfo, descriptorName, 1);
755 ValidateNumOutputs(workloadInfo, descriptorName, 1);
760 std::vector<DataType> supportedTypes =
770 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
771 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
772 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
777 const std::string descriptorName{
"SplitterQueueDescriptor"};
779 ValidateNumInputs(workloadInfo, descriptorName, 1);
782 std::vector<DataType> supportedTypes =
798 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
800 const std::string outputName =
"output_" + std::to_string(i);
801 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
812 descriptorName +
": Number of split windows " 813 "has to match number of workloadInfo.m_OutputTensorInfos. " 814 "Number of windows: " +
815 to_string(m_ViewOrigins.size()) +
816 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
821 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
828 "have the same dimensionality as the input tensor. " 829 "Window origin (index: " +
830 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
831 " dimensions, the input " 833 to_string(inputDims) +
" dimensions.");
835 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
841 "be smaller or equal than the size of the input in that coord.");
849 const std::string descriptorName{
"ConcatQueueDescriptor"};
851 ValidateNumOutputs(workloadInfo, descriptorName, 1);
871 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
876 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
884 descriptorName +
": Number of split windows " 885 "has to match number of workloadInfo.m_InputTensorInfos. " 886 "Number of windows: " +
887 to_string(m_ViewOrigins.size()) +
888 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
893 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
897 if (e.
m_Origin.size() != outputDims)
900 "have the same dimensionality as the output tensor. " 901 "Window origin (index: " +
902 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
903 " dimensions, the output " 905 to_string(outputDims) +
" dimensions.");
908 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
914 "be smaller or equal than the size of the output in that coord.");
920 std::vector<DataType> supportedTypes =
936 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
938 const std::string inputName =
"input_" + std::to_string(i);
939 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
945 const std::string descriptorName{
"StackQueueDescriptor"};
947 ValidateNumOutputs(workloadInfo, descriptorName, 1);
955 const TensorShape& inputShape = m_Parameters.m_InputShape;
974 "than the number of input dimensions.");
979 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
981 if (outputShape[i] != inputShape[i])
984 "match shape inferred from input tensor.");
988 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
991 "match shape inferred from input tensor.");
994 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
996 if (outputShape[i] != inputShape[i-1])
999 "match shape inferred from input tensor.");
1009 std::vector<DataType> supportedTypes =
1021 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1029 "input_" + std::to_string(i));
1041 const std::string descriptorName{
"FillQueueDescriptor"};
1043 ValidateNumInputs(workloadInfo, descriptorName, 1);
1044 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1051 std::vector<DataType> supportedTypes =
1059 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1064 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1066 uint32_t numInputs = 2;
1067 if (m_Parameters.m_BiasEnabled)
1072 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1073 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1088 if (m_Parameters.m_BiasEnabled)
1092 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1098 std::vector<DataType> supportedTypes =
1108 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1116 "for BFloat16 input.");
1121 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1127 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1129 ValidateNumInputs(workloadInfo, descriptorName, 1);
1130 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1136 std::vector<DataType> supportedTypes =
1146 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1148 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1150 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1155 const std::string descriptorName{
"AdditionQueueDescriptor"};
1157 ValidateNumInputs(workloadInfo, descriptorName, 2);
1158 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1164 std::vector<DataType> supportedTypes =
1175 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1176 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1177 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1179 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1180 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1182 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1192 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1194 ValidateNumInputs(workloadInfo, descriptorName, 2);
1195 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1201 std::vector<DataType> supportedTypes =
1212 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1213 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1214 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1216 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1217 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1219 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1229 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1231 ValidateNumInputs(workloadInfo, descriptorName, 1);
1232 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1237 std::vector<DataType> supportedTypes =
1247 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1248 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1250 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1251 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1253 ValidatePointer(m_Mean, descriptorName,
"mean");
1254 ValidatePointer(m_Variance, descriptorName,
"variance");
1255 ValidatePointer(m_Beta, descriptorName,
"beta");
1256 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1258 const TensorInfo& mean = m_Mean->GetTensorInfo();
1259 const TensorInfo& variance = m_Variance->GetTensorInfo();
1260 const TensorInfo& beta = m_Beta->GetTensorInfo();
1261 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1268 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1269 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1270 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1275 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1277 uint32_t numInputs = 2;
1278 if (m_Parameters.m_BiasEnabled)
1283 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1284 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1296 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1299 if (m_Parameters.m_BiasEnabled)
1301 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1305 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1308 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1311 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1312 "cannot be either negative or 0.",
1313 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1316 ValidatePerAxisQuantization(inputTensorInfo,
1319 optionalBiasTensorInfo,
1322 std::vector<DataType> supportedTypes =
1333 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1341 "for BFloat16 input.");
1346 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1352 const std::string descriptorName{
"Convolution3dQueueDescriptor"};
1354 uint32_t numInputs = 2;
1355 if (m_Parameters.m_BiasEnabled)
1359 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1360 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1371 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1374 if (m_Parameters.m_BiasEnabled)
1376 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1380 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1383 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 || m_Parameters.m_StrideZ <= 0 )
1386 fmt::format(
"{}: strideX (provided {}), strideY (provided {}) or strideZ (provided {})" 1387 "cannot be either negative or 0.",
1388 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY, m_Parameters.m_StrideZ));
1391 ValidatePerAxisQuantization(inputTensorInfo,
1394 optionalBiasTensorInfo,
1397 std::vector<DataType> supportedTypes =
1408 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1409 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1414 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1416 uint32_t numInputs = 2;
1417 if (m_Parameters.m_BiasEnabled)
1422 ValidateNumInputs(workloadInfo, descriptorName, numInputs);
1423 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1434 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1437 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) " 1438 "cannot be smaller than 1.",
1439 descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
1442 if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0 )
1445 fmt::format(
"{}: strideX (provided {}) and strideY (provided {}) " 1446 "cannot be either negative or 0.",
1447 descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
1450 if (weightTensorInfo.
GetShape()[0] != 1)
1453 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]." 1454 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
1462 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1463 const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.
GetShape()[3];
1464 const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.
GetShape()[1];
1465 const unsigned int numOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1468 bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
1469 bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
1471 if (!(validRefFormat || validAclFormat))
1474 "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] " 1475 "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is equal to Cout." 1476 "Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
1485 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1488 if (m_Parameters.m_BiasEnabled)
1490 optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.
m_InputTensorInfos[2]);
1493 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1496 ValidatePerAxisQuantization(inputTensorInfo,
1499 optionalBiasTensorInfo,
1502 std::vector<DataType> supportedTypes =
1512 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1513 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1518 const std::string descriptorName{
"PermuteQueueDescriptor"};
1520 ValidateNumInputs(workloadInfo, descriptorName, 1);
1521 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1531 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1533 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1536 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1537 "must match dst dimension " + to_string(mapping[i]) +
1538 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1542 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1547 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1549 ValidateNumInputs(workloadInfo, descriptorName, 1);
1550 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1558 std::vector<DataType> supportedTypes =
1568 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1569 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1574 const std::string descriptorName{
"Pooling3dQueueDescriptor"};
1576 ValidateNumInputs(workloadInfo, descriptorName, 1);
1577 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1585 std::vector<DataType> supportedTypes =
1595 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1596 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1601 const std::string descriptorName{
"ResizeQueueDescriptor"};
1603 ValidateNumInputs(workloadInfo, descriptorName, 1);
1604 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1612 std::vector<DataType> supportedTypes =
1622 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1623 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1626 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1627 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1628 if (inputBatchSize != outputBatchSize)
1631 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1632 descriptorName, inputBatchSize, outputBatchSize));
1638 if (inputChannelCount != outputChannelCount)
1641 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1642 descriptorName, inputChannelCount, outputChannelCount));
1648 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1650 ValidateNumInputs(workloadInfo, descriptorName, 1);
1651 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1659 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1661 if (m_Parameters.m_Min > m_Parameters.m_Max)
1669 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1671 ValidateNumInputs(workloadInfo, descriptorName, 1);
1672 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1682 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1685 std::vector<DataType> supportedTypes =
1692 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1693 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1698 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1700 ValidateNumInputs(workloadInfo, descriptorName, 1);
1701 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1711 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1714 std::vector<DataType> supportedTypes =
1724 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1725 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1730 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1732 ValidateNumInputs(workloadInfo, descriptorName, 1);
1733 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1738 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1740 std::vector<DataType> supportedTypes =
1747 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1748 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1753 const std::string descriptorName{
"ConstantQueueDescriptor"};
1755 ValidateNumInputs(workloadInfo, descriptorName, 0);
1756 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1764 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1767 std::vector<DataType> supportedTypes =
1779 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1784 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1786 ValidateNumInputs(workloadInfo, descriptorName, 1);
1787 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1792 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1795 std::vector<DataType> supportedTypes =
1807 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1808 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1813 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1815 ValidateNumInputs(workloadInfo, descriptorName, 1);
1816 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1824 if (m_Parameters.m_BlockShape.size() != 2)
1829 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1832 "dimensions as Block Shape.");
1837 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1838 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1842 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1843 widthPad.first + widthPad.second;
1844 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1845 heightPad.first + heightPad.second;
1847 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1849 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1851 if (numOutputElements != numInputElements)
1854 to_string(numInputElements) +
" after padding but output tensor has " +
1855 to_string(numOutputElements) +
" elements.");
1858 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1861 "divisible by Block Shape in all spatial dimensions");
1864 std::vector<DataType> supportedTypes =
1874 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1875 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1880 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1882 ValidateNumInputs(workloadInfo, descriptorName, 1);
1883 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1891 std::vector<DataType> supportedTypes =
1901 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1902 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1904 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1906 if (m_Parameters.m_BlockSize == 0)
1912 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1917 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1920 "by block size in all spatial dimensions");
1924 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1927 "must be divisible by the square of block size." );
1933 const std::string descriptorName{
"FloorQueueDescriptor"};
1935 ValidateNumInputs(workloadInfo, descriptorName, 1);
1936 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1941 std::vector<DataType> supportedTypes =
1949 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1950 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1951 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1952 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1959 const std::string descriptorName{
"LstmQueueDescriptor"};
1971 std::vector<DataType> supportedTypes =
1980 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1989 "input_" + std::to_string(i));
1996 "LstmQueueDescriptor",
1998 "output_" + std::to_string(i));
2004 if (m_Parameters.m_ClippingThresCell < 0.0f)
2008 if (m_Parameters.m_ClippingThresProj < 0.0f)
2016 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
2017 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
2018 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
2019 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
2023 descriptorName +
" input_0");
2026 descriptorName +
" input_1");
2029 descriptorName +
" input_2");
2031 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
2033 descriptorName +
" output_0");
2036 descriptorName +
" output_1");
2039 descriptorName +
" output_2");
2042 descriptorName +
" output_3");
2045 if ( m_InputToInputWeights )
2048 (n_cell * n_input),
"InputLayerNormWeights");
2051 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
2053 (n_cell * n_input),
"InputToForgetWeights");
2055 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
2057 (n_cell * n_input),
"InputToCellWeights");
2059 if ( m_RecurrentToInputWeights )
2062 (n_cell * n_output),
"RecurrentToInputWeights");
2065 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
2067 (n_cell * n_output),
"RecurrentToForgetWeights");
2069 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
2071 (n_cell * n_output),
"RecurrentToCellWeights");
2075 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
2076 !m_Parameters.m_CifgEnabled) ||
2077 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
2078 m_Parameters.m_CifgEnabled));
2079 if (!cifg_weights_all_or_none)
2082 "RecurrentToInputWeights must either both be present (regular LSTM) " 2083 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 2087 if ( m_CellToInputWeights )
2090 n_cell,
"CellToInputWeights");
2092 if ( m_CellToForgetWeights )
2095 n_cell,
"CellToForgetWeights");
2097 if ( m_CellToOutputWeights )
2100 n_cell,
"CellToOutputWeights");
2104 bool peephole_weights_all_or_none =
2105 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
2106 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
2107 || ( !m_CellToInputWeights && !m_CellToForgetWeights
2108 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
2109 if (!peephole_weights_all_or_none)
2115 if (m_Parameters.m_CifgEnabled)
2117 if (m_InputGateBias)
2124 if (!m_InputGateBias)
2127 "must be present.");
2130 n_cell,
"InputGateBias");
2133 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2136 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2139 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2142 if (m_ProjectionWeights)
2145 (n_cell * n_output),
"ProjectionWeights");
2147 if (m_ProjectionBias)
2156 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2157 !m_Parameters.m_ProjectionEnabled)
2158 || (m_ProjectionWeights && !m_ProjectionBias &&
2159 m_Parameters.m_ProjectionEnabled)
2160 || (m_ProjectionWeights && m_ProjectionBias &&
2161 m_Parameters.m_ProjectionEnabled));
2162 if (!projecton_tensors_consistent)
2171 if (m_InputLayerNormWeights)
2175 if (m_ForgetLayerNormWeights)
2179 if (m_CellLayerNormWeights)
2183 if (m_OutputLayerNormWeights)
2188 if (m_Parameters.m_LayerNormEnabled)
2190 if (!m_Parameters.m_CifgEnabled)
2192 if (!m_InputLayerNormWeights)
2195 "disabled but InputLayerNormWeights are not present");
2198 1, n_cell,
"InputLayerNormWeights");
2200 else if (m_InputLayerNormWeights)
2206 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2207 "ForgetLayerNormWeights");
2210 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2211 "OutputLayerNormWeights");
2214 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2215 "CellLayerNormWeights");
2218 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2221 "normalisation weights are present.");
2227 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2229 ValidateNumInputs(workloadInfo, descriptorName, 1);
2230 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2245 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2250 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2252 ValidateNumInputs(workloadInfo, descriptorName, 1);
2253 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2268 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2273 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2275 ValidateNumInputs(workloadInfo, descriptorName, 1);
2276 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2291 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2296 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2298 ValidateNumInputs(workloadInfo, descriptorName, 1);
2299 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2314 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2319 const std::string descriptorName{
"DivisionQueueDescriptor"};
2321 ValidateNumInputs(workloadInfo, descriptorName, 2);
2322 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2328 std::vector<DataType> supportedTypes =
2339 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2340 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2341 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2343 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2353 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2355 ValidateNumInputs(workloadInfo, descriptorName, 2);
2356 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2362 std::vector<DataType> supportedTypes =
2373 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2374 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2375 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2377 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2387 const std::string descriptorName{
"MaximumQueueDescriptor"};
2389 ValidateNumInputs(workloadInfo, descriptorName, 2);
2390 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2396 std::vector<DataType> supportedTypes =
2407 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2408 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2409 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2411 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2421 const std::string descriptorName{
"MeanQueueDescriptor"};
2423 ValidateNumInputs(workloadInfo, descriptorName, 1);
2424 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2429 std::vector<DataType> supportedTypes =
2441 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2442 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2444 if (m_Parameters.m_KeepDims)
2448 else if (m_Parameters.m_Axis.empty())
2454 unsigned int outputDim =
2458 outputDim > 0 ? outputDim : 1,
2465 const std::string descriptorName{
"PadQueueDescriptor"};
2467 ValidateNumInputs(workloadInfo, descriptorName, 1);
2468 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2479 "as there are dimensions in the input tensor that is " +
2481 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2487 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2489 ValidateNumInputs(workloadInfo, descriptorName, 1);
2490 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2495 std::vector<DataType> supportedTypes =
2506 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2516 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2518 ValidateNumInputs(workloadInfo, descriptorName, 1);
2519 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2524 std::vector<DataType> supportedTypes =
2534 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2535 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2540 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2542 ValidateNumInputs(workloadInfo, descriptorName, 1);
2543 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2548 std::vector<DataType> supportedTypes =
2558 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2559 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2561 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2570 if (m_Parameters.m_Begin.size() != rank)
2575 if (m_Parameters.m_End.size() != rank)
2580 if (m_Parameters.m_Stride.size() != rank)
2586 for (
auto& stride : m_Parameters.m_Stride)
2597 const std::string descriptorName{
"MinimumQueueDescriptor"};
2599 ValidateNumInputs(workloadInfo, descriptorName, 2);
2600 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2606 std::vector<DataType> supportedTypes =
2617 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2618 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2619 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2621 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2631 const std::string descriptorName{
"DebugQueueDescriptor"};
2633 ValidateNumInputs(workloadInfo, descriptorName, 1);
2634 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2639 const std::string descriptorName{
"EqualQueueDescriptor"};
2641 ValidateNumInputs(workloadInfo, descriptorName, 2);
2642 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2648 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2663 const std::string descriptorName{
"GreaterQueueDescriptor"};
2665 ValidateNumInputs(workloadInfo, descriptorName, 2);
2666 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2672 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2687 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2689 ValidateNumInputs(workloadInfo, descriptorName, 1);
2690 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2695 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2697 std::vector<DataType> supportedTypes =
2707 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2708 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2713 const std::string descriptorName{
"GatherNdQueueDescriptor"};
2715 ValidateNumInputs(workloadInfo, descriptorName, 2);
2716 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2727 std::vector<DataType> supportedTypes =
2738 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2740 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2748 const std::string descriptorName{
"GatherQueueDescriptor"};
2750 ValidateNumInputs(workloadInfo, descriptorName, 2);
2751 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2762 std::vector<DataType> supportedTypes =
2773 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2775 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2783 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2785 ValidateNumInputs(workloadInfo, descriptorName, 2);
2793 if (m_Anchors ==
nullptr)
2800 const TensorInfo& anchorsInfo = m_Anchors->GetTensorInfo();
2811 const std::vector<DataType> supportedInputTypes =
2821 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2822 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2823 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2831 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2832 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2833 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2834 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2836 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2839 "must be positive and less than or equal to 1.");
2842 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2845 "should be equal to number of classes + 1.");
2851 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2853 ValidateNumInputs(workloadInfo, descriptorName, 1);
2854 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2859 std::vector<DataType> inputSupportedTypes =
2867 ValidateDataTypes(inputTensorInfo, inputSupportedTypes, descriptorName);
2869 std::vector<DataType> outputSupportedTypes =
2876 ValidateDataTypes(outputTensorInfo, outputSupportedTypes, descriptorName);
2881 const std::string& descriptorName{
"MergeQueueDescriptor"};
2883 ValidateNumInputs(workloadInfo, descriptorName, 2);
2884 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2890 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2891 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2893 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2894 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2899 const std::string& descriptorName{
"ShapeQueueDescriptor"};
2901 ValidateNumInputs(workloadInfo, descriptorName, 1);
2902 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2907 std::vector<DataType> supportedTypes =
2920 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2921 ValidateDataTypes(outputTensorInfo, {DataType::Signed32}, descriptorName);
2926 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2928 ValidateNumInputs(workloadInfo, descriptorName, 2);
2929 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2937 std::vector<DataType> supportedTypes =
2946 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2947 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2949 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2950 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2952 ValidateTensorShapesMatch(inputTensorInfo0,
2958 ValidateTensorShapesMatch(inputTensorInfo0,
2972 const std::string& descriptorName{
"PreluQueueDescriptor"};
2974 ValidateNumInputs(workloadInfo, descriptorName, 2);
2975 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2981 std::vector<DataType> supportedTypes
2991 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2992 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2994 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2996 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2997 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2999 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
3009 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
3011 ValidateNumInputs(workloadInfo, descriptorName, 1);
3012 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3020 ValidatePointer(m_Weight, descriptorName,
"weight");
3022 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
3025 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
3028 if (m_Parameters.m_BiasEnabled)
3030 ValidatePointer(m_Bias, descriptorName,
"bias");
3032 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
3036 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
3039 ValidatePerAxisQuantization(inputTensorInfo,
3042 optionalBiasTensorInfo,
3045 std::vector<DataType> supportedTypes =
3055 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3056 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3061 const std::string descriptorName{
"TransposeQueueDescriptor"};
3063 ValidateNumInputs(workloadInfo, descriptorName, 1);
3064 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3074 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
3076 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
3079 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
3080 "must match dst dimension " + to_string(i) +
3081 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
3085 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3090 const std::string descriptorName{
"TransposeQueueDescriptor"};
3092 ValidateNumInputs(workloadInfo, descriptorName, 1);
3093 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3098 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3103 const std::string descriptorName{
"QLstmQueueDescriptor"};
3106 ValidateNumInputs(workloadInfo, descriptorName, 3);
3107 ValidateNumOutputs(workloadInfo, descriptorName, 3);
3119 std::vector<DataType> inputOutputSupportedTypes =
3124 std::vector<DataType> cellStateSupportedTypes =
3129 std::vector<DataType> weightsSupportedTypes =
3134 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
3139 std::vector<DataType> biasSupportedTypes =
3145 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3146 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3147 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3149 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3150 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3151 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
3154 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3155 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3156 "outputStateIn",
"outputStateOut");
3157 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3160 const uint32_t numBatches = inputInfo.GetShape()[0];
3161 const uint32_t inputSize = inputInfo.GetShape()[1];
3162 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
3163 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
3175 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3176 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3179 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3180 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3183 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3184 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3187 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3188 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3190 " RecurrentToForgetWeights");
3192 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3193 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3196 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3197 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3201 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3203 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3204 "inputToForgetWeights",
"inputToCellWeights");
3205 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3206 "inputToForgetWeights",
"inputToOutputWeights");
3208 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3209 "inputToForgetWeights",
"recurrentToForgeteights");
3210 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3211 "inputToForgetWeights",
"recurrentToCellWeights");
3212 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3213 "inputToForgetWeights",
"recurrentToOutputWeights");
3216 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3217 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3220 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3221 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3224 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3225 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3229 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3231 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3232 "forgetGateBias",
"cellBias");
3233 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3234 "forgetGateBias",
"outputGateBias");
3237 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3238 !m_Parameters.m_CifgEnabled) ||
3239 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3240 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3242 if (!allCifgParamsPresentOrNot)
3245 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3246 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3247 "set appropriately.");
3250 if (!m_Parameters.m_CifgEnabled)
3253 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3256 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3258 " RecurrentToInputWeights");
3260 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3264 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3265 "inputToForgetWeights",
"inputToInputWeights");
3266 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3267 "inputToForgetWeights",
"recurrentToInputWeights");
3268 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3269 "forgetGateBias",
"inputGateBias");
3273 bool allPeepholeWeightsPresentOrNot =
3274 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3275 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3276 || (!m_CellToInputWeights && !m_CellToForgetWeights
3277 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3279 if (!allPeepholeWeightsPresentOrNot)
3282 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3283 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3284 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3288 if (m_Parameters.m_PeepholeEnabled)
3290 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3292 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3294 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3296 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3297 "cellToForgetWeight",
"cellToOutputWeights");
3299 if (!m_Parameters.m_CifgEnabled)
3301 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3303 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3304 "cellToForgetWeights",
"cellToInputWeights");
3309 bool allLayerNormWeightsPresentOrNot =
3310 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3311 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3312 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3313 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3315 if (!allLayerNormWeightsPresentOrNot)
3318 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3319 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3320 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3321 "only be present when Layer Norm is enabled and CIFG is disabled. " 3322 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3325 if (m_Parameters.m_LayerNormEnabled)
3327 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3329 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3331 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3333 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3334 "forgetLayerNormWeights",
"cellLayerNormWeights");
3336 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3338 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3339 "forgetLayerNormWeights",
"outputLayerNormWeights");
3341 if (!m_Parameters.m_CifgEnabled)
3343 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3345 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3346 "forgetLayerNormWeights",
"inputLayerNormWeights");
3351 bool correctProjectionTensorsPresent =
3352 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3353 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3354 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3356 if (!correctProjectionTensorsPresent)
3359 ": If projection is enabled, ProjectionWeights should be present and " 3360 "ProjectionBias is optional. If projection is disabled, neither " 3361 "ProjectionWeights nor ProjectionBias should be present.");
3364 if (m_Parameters.m_ProjectionEnabled)
3366 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3368 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3370 if (m_ProjectionBias)
3372 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3374 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3378 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3379 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3381 ": If projection is disabled, output quantization info (scale, offset) " 3382 "should match HiddenStateScale and HiddenStateZeroPoint.");
3389 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3392 ValidateNumInputs(workloadInfo, descriptorName, 3);
3393 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3403 std::vector<DataType> inputOutputSupportedTypes =
3408 std::vector<DataType> cellStateSupportedTypes =
3413 std::vector<DataType> weightsSupportedTypes =
3418 std::vector<DataType> biasSupportedTypes =
3424 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3425 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3426 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3428 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3429 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3432 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3433 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3434 "outputStateIn",
"outputStateOut");
3435 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3438 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3439 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3440 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3443 const uint32_t numBatches = inputInfo.GetShape()[0];
3444 const uint32_t inputSize = inputInfo.GetShape()[1];
3445 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3455 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3456 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3459 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3460 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3463 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3464 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3467 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3468 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3471 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3472 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3475 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3476 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3478 " RecurrentToForgetWeights");
3480 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3481 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3484 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3485 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3489 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3491 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3492 "inputToInputWeights",
"inputToForgetWeights");
3493 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3494 "inputToInputWeights",
"inputToCellWeights");
3495 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3496 "inputToInputWeights",
"inputToOutputWeights");
3498 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3499 "inputToInputWeights",
"recurrentToInputWeights");
3500 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3501 "inputToInputWeights",
"recurrentToForgeteights");
3502 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3503 "inputToInputWeights",
"recurrentToCellWeights");
3504 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3505 "inputToInputWeights",
"recurrentToOutputWeights");
3508 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3509 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3510 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3511 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3512 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3513 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3515 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3516 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3517 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3518 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3519 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3520 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3521 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3522 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3525 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3526 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3529 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3530 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3533 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3534 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3537 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3538 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3542 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3544 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3545 "inputGateBias",
"forgetGateBias");
3546 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3547 "inputGateBias",
"cellBias");
3548 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3549 "inputGateBias",
"outputGateBias");
3552 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3553 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3554 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3555 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3560 const std::string descriptorName{
"AbsQueueDescriptor"};
3562 ValidateNumInputs(workloadInfo, descriptorName, 1);
3563 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3568 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3570 std::vector<DataType> supportedTypes =
3581 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3582 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3587 const std::string descriptorName{
"SliceQueueDescriptor"};
3589 ValidateNumInputs(workloadInfo, descriptorName, 1);
3590 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3595 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3606 if (m_Parameters.m_Begin.size() != rank)
3609 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3611 if (m_Parameters.m_Size.size() != rank)
3614 ": Length of size descriptor must equal rank " + std::to_string(rank));
3619 for (
unsigned int i = 0u; i < rank; ++i)
3621 if (m_Parameters.m_Size[i] != outputShape[i])
3630 for(
unsigned int i = 0u; i < rank; ++i)
3632 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3635 std::to_string(i) +
" exceeds input size.");
3642 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3644 ValidateNumInputs(workloadInfo, descriptorName, 1);
3645 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3653 std::vector<DataType> supportedTypes =
3663 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3664 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3666 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3668 if (m_Parameters.m_BlockSize == 0)
3674 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3679 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3682 "must be divisible by block size.");
3686 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3689 "must be divisible by the square of block size." );
3695 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3697 ValidateNumInputs(workloadInfo, descriptorName, 2);
3698 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3704 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3719 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3721 ValidateNumInputs(workloadInfo, descriptorName, 1);
3722 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3727 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3729 std::vector<DataType> supportedTypes =
3740 std::vector<DataType> logicalSupportedTypes =
3747 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3751 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3755 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3760 const std::string descriptorName{
"RankQueueDescriptor"};
3762 ValidateNumInputs(workloadInfo, descriptorName, 1);
3763 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3769 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3771 std::vector<DataType> supportedTypes =
3783 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3784 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3789 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3791 ValidateNumInputs(workloadInfo, descriptorName, 2);
3792 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3798 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3823 const std::string descriptorName{
"ReduceQueueDescriptor"};
3825 ValidateNumInputs(workloadInfo, descriptorName, 1);
3826 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3831 std::vector<DataType> supportedTypes =
3842 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3843 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3850 const std::string descriptorName{
"UnidirectionalSequenceLstmQueueDescriptor"};
3862 std::vector<DataType> supportedTypes =
3869 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
3874 if (m_Parameters.m_ClippingThresCell < 0.0f)
3878 if (m_Parameters.m_ClippingThresProj < 0.0f)
3883 unsigned int batchIndx = 0;
3884 unsigned int inputIndx = 1;
3885 uint32_t timeStep = 1;
3886 unsigned int timeIndx = 1;
3888 if (m_Parameters.m_TimeMajor)
3899 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
3900 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
3901 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
3902 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
3906 descriptorName +
" input_0");
3909 descriptorName +
" input_1");
3912 descriptorName +
" input_2");
3916 descriptorName +
" output_0");
3919 if ( m_InputToInputWeights )
3922 (n_cell * n_input),
"InputLayerNormWeights");
3925 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
3927 (n_cell * n_input),
"InputToForgetWeights");
3929 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
3931 (n_cell * n_input),
"InputToCellWeights");
3933 if ( m_RecurrentToInputWeights )
3936 (n_cell * n_output),
"RecurrentToInputWeights");
3939 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
3941 (n_cell * n_output),
"RecurrentToForgetWeights");
3943 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
3945 (n_cell * n_output),
"RecurrentToCellWeights");
3949 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
3950 !m_Parameters.m_CifgEnabled) ||
3951 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3952 m_Parameters.m_CifgEnabled));
3953 if (!cifg_weights_all_or_none)
3956 "RecurrentToInputWeights must either both be present (regular LSTM) " 3957 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 3961 if ( m_CellToInputWeights )
3964 n_cell,
"CellToInputWeights");
3966 if ( m_CellToForgetWeights )
3969 n_cell,
"CellToForgetWeights");
3971 if ( m_CellToOutputWeights )
3974 n_cell,
"CellToOutputWeights");
3978 bool peephole_weights_all_or_none =
3979 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3980 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3981 || ( !m_CellToInputWeights && !m_CellToForgetWeights
3982 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3983 if (!peephole_weights_all_or_none)
3989 if (m_Parameters.m_CifgEnabled)
3991 if (m_InputGateBias)
3998 if (!m_InputGateBias)
4001 "must be present.");
4004 n_cell,
"InputGateBias");
4007 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
4010 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
4013 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
4016 if (m_ProjectionWeights)
4019 (n_cell * n_output),
"ProjectionWeights");
4021 if (m_ProjectionBias)
4030 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
4031 !m_Parameters.m_ProjectionEnabled)
4032 || (m_ProjectionWeights && !m_ProjectionBias &&
4033 m_Parameters.m_ProjectionEnabled)
4034 || (m_ProjectionWeights && m_ProjectionBias &&
4035 m_Parameters.m_ProjectionEnabled));
4036 if (!projecton_tensors_consistent)
4045 if (m_InputLayerNormWeights)
4049 if (m_ForgetLayerNormWeights)
4053 if (m_CellLayerNormWeights)
4057 if (m_OutputLayerNormWeights)
4062 if (m_Parameters.m_LayerNormEnabled)
4064 if (!m_Parameters.m_CifgEnabled)
4066 if (!m_InputLayerNormWeights)
4069 "disabled but InputLayerNormWeights are not present");
4072 1, n_cell,
"InputLayerNormWeights");
4074 else if (m_InputLayerNormWeights)
4080 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
4081 "ForgetLayerNormWeights");
4084 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
4085 "OutputLayerNormWeights");
4088 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
4089 "CellLayerNormWeights");
4092 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
4095 "normalisation weights are present.");
4101 const std::string descriptorName{
"BatchMatMulDescriptor"};
4103 ValidateNumInputs(workloadInfo, descriptorName, 2);
4104 ValidateNumOutputs(workloadInfo, descriptorName, 1);
4115 std::vector<DataType> supportedTypes =
4125 ValidateDataTypes(inputXInfoBeforeParams, supportedTypes, descriptorName);
4126 ValidateDataTypes(inputYInfoBeforeParams, supportedTypes, descriptorName);
4127 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
4129 if ((inputXInfoBeforeParams.GetNumDimensions() < 2) ||
4130 (inputYInfoBeforeParams.GetNumDimensions() < 2))
4138 if((m_Parameters.m_TransposeX && m_Parameters.m_AdjointX) ||
4139 (m_Parameters.m_TransposeY && m_Parameters.m_AdjointY))
4142 ": Invalid descriptor parameters - Transpose and Adjoint " 4143 "cannot both be true for a given input tensor.");
4145 if(m_Parameters.m_TransposeX)
4149 m_Parameters.m_DataLayoutX,
4150 inputXInfoBeforeParams.GetShape()));
4152 else if(m_Parameters.m_AdjointX)
4155 inputXInfoBeforeParams.GetShape());
4156 if(inputXInfoBeforeParams.GetShape()[axesToMul.first] !=
4157 inputXInfoBeforeParams.GetShape()[axesToMul.second])
4160 ": Adjoint is set to true for input tensor X, but the axes to be adjointed are not square." );
4163 inputXInfoAfterParams = inputXInfoBeforeParams;
4167 inputXInfoAfterParams = inputXInfoBeforeParams;
4170 if(m_Parameters.m_TransposeY)
4174 m_Parameters.m_DataLayoutY,
4175 inputYInfoBeforeParams.GetShape()));
4177 else if(m_Parameters.m_AdjointY)
4180 inputYInfoBeforeParams.GetShape());
4181 if(inputYInfoBeforeParams.GetShape()[axesToMul.first] !=
4182 inputYInfoBeforeParams.GetShape()[axesToMul.second])
4185 ": Adjoint is set to true for input tensor Y, but the axes to be adjointed are not square." );
4188 inputYInfoAfterParams = inputYInfoBeforeParams;
4192 inputYInfoAfterParams = inputYInfoBeforeParams;
4195 switch(m_Parameters.m_DataLayoutX)
4202 ": Input tensor X does not have the correct " 4203 "number of dimensions for the Data Layout that it has been assigned.");
4212 switch(m_Parameters.m_DataLayoutY)
4219 ": Input tensor Y does not have the correct " 4220 "number of dimensions for the Data Layout that it has been assigned.");
4232 inputXInfoBeforeParams.GetShape());
4234 if(inputXInfoAfterParams.
GetShape()[axesXToMul.second]
4235 != inputYInfoAfterParams.
GetShape()[axesYToMul.first])
4238 ": The final axis of input tensor X must be the same size as " 4239 "the second last axis of input tensor Y.");
4244 DataLayout xLayout = m_Parameters.m_DataLayoutX;
4245 DataLayout yLayout = m_Parameters.m_DataLayoutY;
4252 ": Invalid input tensor data layout combination.");
4260 ": Invalid input tensor data layout combination.");
4266 unsigned int outputTensorDimSize = std::max(inputXInfoAfterParams.
GetNumDimensions(),
4268 if(outputTensorDimSize-2 > 0)
4277 auto doAxisExtension = [&](std::vector<unsigned int> axisIndices,
TensorInfo& ti)
4279 auto sizeDiff = (outputTensorDimSize-2) - axisIndices.size();
4281 for(
unsigned int i = 0; i < sizeDiff; i++)
4283 axisIndices.insert(axisIndices.begin(), 1);
4286 for(
unsigned int i = 0; i < ti.GetNumDimensions(); i++)
4288 ti.GetShape()[i] = inputXInfoAfterParams.
GetShape()[i];
4297 doAxisExtension(axesXNotMul, tiXNotMul);
4298 doAxisExtension(axesYNotMul, tiYNotMul);
4306 ValidateBroadcastTensorShapesMatch(tiXNotMul,
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool HasPerAxisQuantization() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void ValidateTensorNumDimNumElem(const TensorInfo &tensorInfo, unsigned int numDimension, unsigned int numElements, std::string const &tensorName) 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
static PermutationVector GetPermuteVec(DataLayout dataLayout, const TensorShape &tensorShape)
Static helper to get the axes which will be transposed.
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
static std::pair< std::vector< unsigned int >, std::vector< unsigned int > > GetAxesNotMul(const BatchMatMulDescriptor &desc, const TensorShape &inputXShape, const TensorShape &inputYShape)
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
static std::pair< std::pair< unsigned int, unsigned int >, std::pair< unsigned int, unsigned int > > GetAxesToMul(const BatchMatMulDescriptor &desc, const TensorShape &tensorXShape, const TensorShape &tensorYShape)
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 ValidateTensorNumDimensions(const TensorInfo &tensor, std::string const &descName, unsigned int numDimensions, std::string const &tensorName) 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
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
armnn::TensorShape Permuted(const armnn::TensorShape &srcShape, const armnn::PermutationVector &mappings)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetNumElements() const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< unsigned int > m_Origin