17 #include <fmt/format.h> 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 matching number of per-axis quantization scales for weights and bias, " 243 <<
"but got different values. This is currently unsupported: weights=" << weightScales.size()
244 <<
", biases=" << biasScales.size();
248 for (
size_t i = 0ul; i < biasScales.size(); ++i)
251 VerifyBiasQuantizationScale(biasScales[i], expectedScale);
263 void ValidateTensors(
const std::vector<ITensorHandle*>& vec,
264 unsigned int numExpected,
265 const std::string& descName,
266 const std::string& varName)
268 if (vec.empty() && numExpected > 0)
273 for (
unsigned int i = 0; i < numExpected; ++i)
283 void ValidateBroadcastTensorShapesMatch(
const TensorInfo& first,
286 std::string
const& descName,
287 std::string
const& firstName,
288 std::string
const& secondName)
295 + firstName +
" & " + secondName
296 +
" must have the same number of dimensions in order to be broadcasted");
299 std::vector<uint32_t> outputDims(numDims, 0u);
300 for (uint32_t i = 0; i < numDims; i++)
303 const bool dimsNotOne = (first.
GetShape()[i] != 1) && (second.
GetShape()[i] != 1);
304 if (dimsNotEqual && dimsNotOne)
310 TensorShape broadcastShape =
TensorShape(armnn::numeric_cast<unsigned int>(outputDims.size()), outputDims.data());
311 if (broadcastShape != output.
GetShape())
314 + firstName +
" & " + secondName
315 +
" does not match the output shape");
321 const std::vector<armnn::DataType>& supportedTypes,
322 std::string
const& descName)
324 auto iterator = std::find(supportedTypes.begin(), supportedTypes.end(), info.
GetDataType());
325 if (iterator == supportedTypes.end())
332 void ValidateTensorDataTypesMatch(
const TensorInfo& first,
334 std::string
const& descName,
335 std::string
const& firstName,
336 std::string
const& secondName)
341 " must have identical data types.");
346 void ValidateTensorNumElementsMatch(
const TensorInfo& first,
348 std::string
const& descName,
349 std::string
const& firstName,
350 std::string
const& secondName)
355 " must have the same number of elements.");
359 void ValidateWeightDataType(
const TensorInfo& inputInfo,
361 const std::string& descName)
367 const std::vector<DataType> validTypes =
372 DataType::QuantizedSymm8PerAxis
376 ValidateDataTypes(weightInfo, validTypes, descName);
380 ValidateTensorDataTypesMatch(inputInfo, weightInfo, descName,
"input",
"weight");
384 void ValidatePerAxisQuantizationDimension(
const TensorInfo& tensorInfo,
385 const std::string& descName,
386 const std::string& tensorName)
392 "not set on tensor {1}.", descName, tensorName));
395 if (quantizationDim.
value() != 0)
398 "{0}: Quantization dimension for per-axis quantization expected to be 0 on tensor {1}, " 399 "but got: {2}", 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 "{0}: Quantization offset for per-axis quantization expected to be 0 on tensor {1}, but got: {2}",
412 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 "{0}: Per-axis quantization parameters set on tensor {1}, but data type does not support " 433 "per-axis quantization.", descName,
"weight"));
437 ValidPerAxisQuantizedDataType(weightInfo, descName,
"weight");
438 ValidatePerAxisQuantizationDimension(weightInfo, descName,
"weight");
439 ValidatePerAxisQuantizationOffset(weightInfo, descName,
"weight");
447 "{}: Per-axis quantization parameters not set on bias tensor, " 448 "despite being set on 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{
"MapQueueDescriptor"};
472 ValidateNumInputs(workloadInfo, descriptorName, 1);
473 ValidateNumOutputs(workloadInfo, descriptorName, 0);
475 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
480 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
488 const std::string descriptorName{
"UnmapQueueDescriptor"};
490 ValidateNumInputs(workloadInfo, descriptorName, 1);
491 ValidateNumOutputs(workloadInfo, descriptorName, 0);
493 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
498 fmt::format(
"{}: Invalid NULL input {}.", descriptorName, static_cast<int>(i)));
506 const std::string descriptorName{
"MemCopyQueueDescriptor"};
508 ValidateNumInputs(workloadInfo, descriptorName, 1);
509 ValidateNumOutputs(workloadInfo, descriptorName , 1);
514 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
515 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
520 "{0}: Number of inputs ({1}) does not match the number of outputs ({2}).",
524 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
529 "{0}: Invalid NULL input {1}.", descriptorName, i));
542 ValidateNumInputs(workloadInfo,
"MemImportQueueDescriptor", 1);
543 ValidateNumOutputs(workloadInfo,
"MemImportQueueDescriptor" , 1);
555 "Number of input infos ({0}) does not match the number of output infos ({1})",
565 "Number of elements for tensor input and output {} does not match", i ));
577 "Number of inputs ({0}) does not match the number of outputs ({1})",
581 for (
unsigned int i = 0; i <
m_Inputs.size(); ++i)
598 ValidateNumInputs(workloadInfo,
"MemSyncQueueDescriptor", 1);
599 ValidateNumOutputs(workloadInfo,
"MemSyncQueueDescriptor" , 1);
620 const std::string descriptorName{
"ActivationQueueDescriptor"};
622 ValidateNumInputs(workloadInfo, descriptorName, 1);
623 ValidateNumOutputs(workloadInfo, descriptorName, 1);
628 std::vector<DataType> supportedTypes =
638 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
639 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
640 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
645 const std::string descriptorName{
"ArgMinMaxQueueDescriptor"};
647 ValidateNumInputs(workloadInfo, descriptorName, 1);
648 ValidateNumOutputs(workloadInfo, descriptorName, 1);
659 std::vector<DataType> supportedInputTypes =
671 ValidateDataTypes(inputTensorInfo, supportedInputTypes, descriptorName);
673 auto inputShape = inputTensorInfo.
GetShape();
674 auto outputShape = outputTensorInfo.
GetShape();
679 const std::string outputShapeError{
": Output tensor shape does not match shape inferred from input tensor."};
682 if (inputShape.GetNumDimensions() == 1)
684 if (outputShape.GetNumDimensions() != 1 && outputShape[0] != 1)
691 for (
unsigned int i = 0; i < unsignedAxis; ++i)
693 if (outputShape[i] != inputShape[i])
699 for (
auto i = unsignedAxis + 1; i < inputNumDimensions; ++i)
701 if (outputShape[i - 1] != inputShape[i])
711 const std::string descriptorName{
"SoftmaxQueueDescriptor"};
713 ValidateNumInputs(workloadInfo, descriptorName, 1);
714 ValidateNumOutputs(workloadInfo, descriptorName, 1);
719 std::vector<DataType> supportedTypes =
729 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
730 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
731 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
736 const std::string descriptorName{
"SplitterQueueDescriptor"};
738 ValidateNumInputs(workloadInfo, descriptorName, 1);
741 std::vector<DataType> supportedTypes =
757 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
759 const std::string outputName =
"output_" + std::to_string(i);
760 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input", outputName);
771 descriptorName +
": Number of split windows " 772 "has to match number of workloadInfo.m_OutputTensorInfos. " 773 "Number of windows: " +
774 to_string(m_ViewOrigins.size()) +
775 ". Number of workloadInfo.m_OutputTensorInfos: " + to_string(workloadInfo.
m_OutputTensorInfos.size()));
780 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
787 "have the same dimensionality as the input tensor. " 788 "Window origin (index: " +
789 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
790 " dimensions, the input " 792 to_string(inputDims) +
" dimensions.");
794 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
800 "be smaller or equal than the size of the input in that coord.");
808 const std::string descriptorName{
"ConcatQueueDescriptor"};
810 ValidateNumOutputs(workloadInfo, descriptorName, 1);
830 if(m_Parameters.GetConcatAxis() > workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions())
835 if (workloadInfo.
m_InputTensorInfos[0].GetShape().GetNumDimensions() - m_Parameters.GetConcatAxis() == 1)
843 descriptorName +
": Number of split windows " 844 "has to match number of workloadInfo.m_InputTensorInfos. " 845 "Number of windows: " +
846 to_string(m_ViewOrigins.size()) +
847 ". Number of workloadInfo.m_InputTensorInfos: " + to_string(workloadInfo.
m_InputTensorInfos.size()));
852 for(
unsigned int w = 0; w < m_ViewOrigins.size(); ++w )
856 if (e.
m_Origin.size() != outputDims)
859 "have the same dimensionality as the output tensor. " 860 "Window origin (index: " +
861 to_string(w) +
") has " + to_string(e.
m_Origin.size()) +
862 " dimensions, the output " 864 to_string(outputDims) +
" dimensions.");
867 for (
unsigned int i = 0; i < e.
m_Origin.size(); ++i)
873 "be smaller or equal than the size of the output in that coord.");
879 std::vector<DataType> supportedTypes =
895 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
897 const std::string inputName =
"input_" + std::to_string(i);
898 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, inputName,
"output");
904 const std::string descriptorName{
"StackQueueDescriptor"};
906 ValidateNumOutputs(workloadInfo, descriptorName, 1);
914 const TensorShape& inputShape = m_Parameters.m_InputShape;
933 "than the number of input dimensions.");
938 for (
unsigned int i = 0; i < m_Parameters.m_Axis; ++i)
940 if (outputShape[i] != inputShape[i])
943 "match shape inferred from input tensor.");
947 if (outputShape[m_Parameters.m_Axis] != m_Parameters.m_NumInputs)
950 "match shape inferred from input tensor.");
953 for (
unsigned int i = m_Parameters.m_Axis + 1; i < inputShape.
GetNumDimensions() + 1; ++i)
955 if (outputShape[i] != inputShape[i-1])
958 "match shape inferred from input tensor.");
968 std::vector<DataType> supportedTypes =
980 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
988 "input_" + std::to_string(i));
1000 const std::string descriptorName{
"FillQueueDescriptor"};
1002 ValidateNumInputs(workloadInfo, descriptorName, 1);
1003 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1008 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 1,
"input");
1010 std::vector<DataType> supportedTypes =
1018 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1023 const std::string descriptorName{
"FullyConnectedQueueDescriptor"};
1025 ValidateNumInputs(workloadInfo, descriptorName, 1);
1026 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1031 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1038 ValidatePointer(m_Weight, descriptorName,
"weight");
1040 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1041 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 2,
"weight");
1043 if (m_Parameters.m_BiasEnabled)
1045 ValidatePointer(m_Bias, descriptorName,
"bias");
1048 const TensorInfo& biasTensorInfo = m_Bias->GetTensorInfo();
1049 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1052 ValidateTensorNumDimensions(biasTensorInfo, descriptorName, 1,
"bias");
1056 std::vector<DataType> supportedTypes =
1066 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1074 "for BFloat16 input.");
1079 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1085 const std::string descriptorName{
"NormalizationQueueDescriptor"};
1087 ValidateNumInputs(workloadInfo, descriptorName, 1);
1088 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1094 std::vector<DataType> supportedTypes =
1104 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1106 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1108 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1113 const std::string descriptorName{
"AdditionQueueDescriptor"};
1115 ValidateNumInputs(workloadInfo, descriptorName, 2);
1116 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1122 std::vector<DataType> supportedTypes =
1133 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1134 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1135 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1137 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1138 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1140 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1150 const std::string descriptorName{
"MultiplicationQueueDescriptor"};
1152 ValidateNumInputs(workloadInfo, descriptorName, 2);
1153 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1159 std::vector<DataType> supportedTypes =
1170 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
1171 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
1172 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1174 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
1175 ValidateTensorDataTypesMatch(inputTensorInfo1, outputTensorInfo, descriptorName,
"input_1",
"output");
1177 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
1187 const std::string descriptorName{
"BatchNormalizationQueueDescriptor"};
1189 ValidateNumInputs(workloadInfo, descriptorName, 1);
1190 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1195 std::vector<DataType> supportedTypes =
1205 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1206 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1208 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1209 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1211 ValidatePointer(m_Mean, descriptorName,
"mean");
1212 ValidatePointer(m_Variance, descriptorName,
"variance");
1213 ValidatePointer(m_Beta, descriptorName,
"beta");
1214 ValidatePointer(m_Gamma, descriptorName,
"gamma");
1216 const TensorInfo& mean = m_Mean->GetTensorInfo();
1217 const TensorInfo& variance = m_Variance->GetTensorInfo();
1218 const TensorInfo& beta = m_Beta->GetTensorInfo();
1219 const TensorInfo& gamma = m_Gamma->GetTensorInfo();
1221 ValidateTensorNumDimensions(mean, descriptorName, 1,
"mean");
1222 ValidateTensorNumDimensions(variance, descriptorName, 1,
"variance");
1223 ValidateTensorNumDimensions(beta, descriptorName, 1,
"beta");
1224 ValidateTensorNumDimensions(gamma, descriptorName, 1,
"gamma");
1226 ValidateTensorShapesMatch(mean, variance, descriptorName,
"mean",
"variance");
1227 ValidateTensorShapesMatch(mean, beta, descriptorName,
"mean",
"beta");
1228 ValidateTensorShapesMatch(mean, gamma, descriptorName,
"mean",
"gamma");
1233 const std::string descriptorName{
"Convolution2dQueueDescriptor"};
1235 ValidateNumInputs(workloadInfo, descriptorName, 1);
1236 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1241 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1242 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1244 ValidatePointer(m_Weight, descriptorName,
"weight");
1246 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1247 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1249 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1252 if (m_Parameters.m_BiasEnabled)
1254 ValidatePointer(m_Bias, descriptorName,
"bias");
1256 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1260 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1263 ValidatePerAxisQuantization(inputTensorInfo,
1266 optionalBiasTensorInfo,
1269 std::vector<DataType> supportedTypes =
1280 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1288 "for BFloat16 input.");
1293 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1299 const std::string descriptorName{
"DepthwiseConvolution2dQueueDescriptor"};
1301 ValidateNumInputs(workloadInfo, descriptorName, 1);
1302 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1307 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1308 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1310 ValidatePointer(m_Weight, descriptorName,
"weight");
1312 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
1313 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
1315 if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
1318 fmt::format(
"{}: dilationX (provided {}) and dilationY (provided {}) " 1319 "cannot be smaller than 1.",
1320 descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
1323 const unsigned int channelIndex = (m_Parameters.m_DataLayout ==
DataLayout::NCHW) ? 1 : 3;
1327 const unsigned int numWeightChannelMultiplier = weightTensorInfo.
GetShape()[0];
1328 const unsigned int numWeightInputChannels = weightTensorInfo.
GetShape()[1];
1329 const unsigned int numWeightOutputChannels = outputTensorInfo.
GetShape()[channelIndex];
1330 if (numWeightChannelMultiplier * numWeightInputChannels != numWeightOutputChannels)
1333 "{0}: output_channels (provided {1}) should be equal to input_channels (provided {2}) " 1334 "multiplied by channel_multiplier (provided {3}).",
1335 descriptorName, numWeightOutputChannels, numWeightInputChannels, numWeightChannelMultiplier));
1338 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
1341 if (m_Parameters.m_BiasEnabled)
1343 ValidatePointer(m_Bias, descriptorName,
"bias");
1345 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
1348 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
1351 ValidatePerAxisQuantization(inputTensorInfo,
1354 optionalBiasTensorInfo,
1357 std::vector<DataType> supportedTypes =
1367 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1368 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1373 const std::string descriptorName{
"PermuteQueueDescriptor"};
1375 ValidateNumInputs(workloadInfo, descriptorName, 1);
1376 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1383 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
1384 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
1386 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
1388 if (inputTensorInfo.
GetShape()[i] != outputTensorInfo.
GetShape()[mapping[i]])
1391 " (=" + to_string(inputTensorInfo.
GetShape()[i]) +
") " +
1392 "must match dst dimension " + to_string(mapping[i]) +
1393 " (=" + to_string(outputTensorInfo.
GetShape()[mapping[i]]) +
")");
1397 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1402 const std::string descriptorName{
"Pooling2dQueueDescriptor"};
1404 ValidateNumInputs(workloadInfo, descriptorName, 1);
1405 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1410 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1411 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1413 std::vector<DataType> supportedTypes =
1423 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1424 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1429 const std::string descriptorName{
"ResizeBilinearQueueDescriptor"};
1431 ValidateNumInputs(workloadInfo, descriptorName, 1);
1432 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1437 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1438 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1440 std::vector<DataType> supportedTypes =
1450 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1451 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1454 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1455 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1456 if (inputBatchSize != outputBatchSize)
1459 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1460 descriptorName, inputBatchSize, outputBatchSize));
1466 if (inputChannelCount != outputChannelCount)
1469 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1470 descriptorName, inputChannelCount, outputChannelCount));
1476 const std::string descriptorName{
"ResizeQueueDescriptor"};
1478 ValidateNumInputs(workloadInfo, descriptorName, 1);
1479 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1484 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1485 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1487 std::vector<DataType> supportedTypes =
1497 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1498 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1501 const unsigned int inputBatchSize = inputTensorInfo.
GetShape()[0];
1502 const unsigned int outputBatchSize = outputTensorInfo.
GetShape()[0];
1503 if (inputBatchSize != outputBatchSize)
1506 fmt::format(
"{}: Input batch size ({}) does not match output batch size ({})",
1507 descriptorName, inputBatchSize, outputBatchSize));
1513 if (inputChannelCount != outputChannelCount)
1516 fmt::format(
"{}: Input channel count ({}) does not match output channel count ({})",
1517 descriptorName, inputChannelCount, outputChannelCount));
1523 const std::string descriptorName{
"FakeQuantizationQueueDescriptor"};
1525 ValidateNumInputs(workloadInfo, descriptorName, 1);
1526 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1531 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 2,
"input");
1532 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 2,
"output");
1534 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1536 if (m_Parameters.m_Min > m_Parameters.m_Max)
1544 const std::string descriptorName{
"InstanceNormalizationQueueDescriptor"};
1546 ValidateNumInputs(workloadInfo, descriptorName, 1);
1547 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1557 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1560 std::vector<DataType> supportedTypes =
1567 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1568 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1573 const std::string descriptorName{
"L2NormalizationQueueDescriptor"};
1575 ValidateNumInputs(workloadInfo, descriptorName, 1);
1576 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1586 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1589 std::vector<DataType> supportedTypes =
1599 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1600 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1605 const std::string descriptorName{
"LogSoftmaxQueueDescriptor"};
1607 ValidateNumInputs(workloadInfo, descriptorName, 1);
1608 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1613 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1615 std::vector<DataType> supportedTypes =
1622 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1623 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1628 const std::string descriptorName{
"ConstantQueueDescriptor"};
1630 ValidateNumInputs(workloadInfo, descriptorName, 0);
1631 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1639 ValidateTensorShapesMatch(m_LayerOutput->GetTensorInfo(), outputTensorInfo, descriptorName,
"constant",
"output");
1642 std::vector<DataType> supportedTypes =
1654 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1659 const std::string descriptorName{
"ReshapeQueueDescriptor"};
1661 ValidateNumInputs(workloadInfo, descriptorName, 1);
1662 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1667 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1670 std::vector<DataType> supportedTypes =
1682 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1683 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1688 const std::string descriptorName{
"SpaceToBatchNdQueueDescriptor"};
1690 ValidateNumInputs(workloadInfo, descriptorName, 1);
1691 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1696 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1697 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1699 if (m_Parameters.m_BlockShape.size() != 2)
1704 if (m_Parameters.m_BlockShape.size() != m_Parameters.m_PadList.size())
1707 "dimensions as Block Shape.");
1712 std::pair<unsigned int, unsigned int> heightPad = m_Parameters.m_PadList[0];
1713 std::pair<unsigned int, unsigned int> widthPad = m_Parameters.m_PadList[1];
1717 const unsigned int inputWidth = inputShape[dimensionIndices.
GetWidthIndex()] +
1718 widthPad.first + widthPad.second;
1719 const unsigned int inputHeight = inputShape[dimensionIndices.
GetHeightIndex()] +
1720 heightPad.first + heightPad.second;
1722 const unsigned int numInputElements = inputShape[0] * inputHeight * inputWidth *
1724 const unsigned int numOutputElements = outputTensorInfo.
GetNumElements();
1726 if (numOutputElements != numInputElements)
1729 to_string(numInputElements) +
" after padding but output tensor has " +
1730 to_string(numOutputElements) +
" elements.");
1733 if (inputHeight % m_Parameters.m_BlockShape[0] != 0 || inputWidth % m_Parameters.m_BlockShape[1] != 0)
1736 "divisible by Block Shape in all spatial dimensions");
1739 std::vector<DataType> supportedTypes =
1749 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1750 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1755 const std::string descriptorName{
"SpaceToDepthQueueDescriptor"};
1757 ValidateNumInputs(workloadInfo, descriptorName, 1);
1758 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1763 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
1764 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
1766 std::vector<DataType> supportedTypes =
1776 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1777 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
1779 ValidateTensorNumElementsMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
1781 if (m_Parameters.m_BlockSize == 0)
1787 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
1792 if (inputShape[hIndex] % m_Parameters.m_BlockSize != 0 || inputShape[wIndex] % m_Parameters.m_BlockSize != 0)
1795 "by block size in all spatial dimensions");
1799 if (outputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
1802 "must be divisible by the square of block size." );
1808 const std::string descriptorName{
"FloorQueueDescriptor"};
1810 ValidateNumInputs(workloadInfo, descriptorName, 1);
1811 ValidateNumOutputs(workloadInfo, descriptorName, 1);
1816 std::vector<DataType> supportedTypes =
1824 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
1826 if (inputTensorInfo != outputTensorInfo)
1836 const std::string descriptorName{
"LstmQueueDescriptor"};
1848 std::vector<DataType> supportedTypes =
1857 ValidateDataTypes(workloadInfo.
m_InputTensorInfos[0], supportedTypes, descriptorName);
1866 "input_" + std::to_string(i));
1873 "LstmQueueDescriptor",
1875 "output_" + std::to_string(i));
1881 if (m_Parameters.m_ClippingThresCell < 0.0f)
1885 if (m_Parameters.m_ClippingThresProj < 0.0f)
1894 ValidatePointer(m_InputToOutputWeights,
"Null pointer check",
"InputToOutputWeights");
1895 const uint32_t n_cell = m_InputToOutputWeights->GetShape()[0];
1896 ValidatePointer(m_RecurrentToOutputWeights,
"Null pointer check",
"RecurrentToOutputWeights");
1897 const uint32_t n_output = m_RecurrentToOutputWeights->GetShape()[1];
1900 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[0], 2, (n_batch * n_input),
1901 descriptorName +
" input_0");
1903 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[1], 2, (n_batch * n_output),
1904 descriptorName +
" input_1");
1906 ValidateTensorNumDimNumElem(workloadInfo.
m_InputTensorInfos[2], 2, (n_batch * n_cell),
1907 descriptorName +
" input_2");
1909 unsigned int scratchBufferSize = m_Parameters.m_CifgEnabled ? n_cell * 3 : n_cell * 4;
1910 ValidateTensorNumDimNumElem(workloadInfo.
m_OutputTensorInfos[0], 2, (n_batch * scratchBufferSize),
1911 descriptorName +
" output_0");
1914 descriptorName +
" output_1");
1917 descriptorName +
" output_2");
1920 descriptorName +
" output_3");
1924 if ( m_InputToInputWeights )
1926 ValidateTensorNumDimNumElem(m_InputToInputWeights->GetTensorInfo(), 2,
1927 (n_cell * n_input),
"InputLayerNormWeights");
1930 ValidatePointer(m_InputToForgetWeights,
"Null pointer check",
"InputToForgetWeights");
1931 ValidateTensorNumDimNumElem(m_InputToForgetWeights->GetTensorInfo(), 2,
1932 (n_cell * n_input),
"InputToForgetWeights");
1934 ValidatePointer(m_InputToCellWeights,
"Null pointer check",
"InputToCellWeights");
1935 ValidateTensorNumDimNumElem(m_InputToCellWeights->GetTensorInfo(), 2,
1936 (n_cell * n_input),
"InputToCellWeights");
1938 if ( m_RecurrentToInputWeights )
1940 ValidateTensorNumDimNumElem(m_RecurrentToInputWeights->GetTensorInfo(), 2,
1941 (n_cell * n_output),
"RecurrentToInputWeights");
1944 ValidatePointer(m_RecurrentToForgetWeights,
"Null pointer check",
"RecurrentToForgetWeights");
1945 ValidateTensorNumDimNumElem(m_RecurrentToForgetWeights->GetTensorInfo(), 2,
1946 (n_cell * n_output),
"RecurrentToForgetWeights");
1948 ValidatePointer(m_RecurrentToCellWeights,
"Null pointer check",
"RecurrentToCellWeights");
1949 ValidateTensorNumDimNumElem(m_RecurrentToCellWeights->GetTensorInfo(), 2,
1950 (n_cell * n_output),
"RecurrentToCellWeights");
1954 bool cifg_weights_all_or_none = ((m_InputToInputWeights && m_RecurrentToInputWeights &&
1955 !m_Parameters.m_CifgEnabled) ||
1956 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
1957 m_Parameters.m_CifgEnabled));
1958 if (!cifg_weights_all_or_none)
1961 "RecurrentToInputWeights must either both be present (regular LSTM) " 1962 "or both not present (CIFG-LSTM). In addition CifgEnable must be set " 1966 if ( m_CellToInputWeights )
1968 ValidateTensorNumDimNumElem(m_CellToInputWeights->GetTensorInfo(), 1,
1969 n_cell,
"CellToInputWeights");
1971 if ( m_CellToForgetWeights )
1973 ValidateTensorNumDimNumElem(m_CellToForgetWeights->GetTensorInfo(), 1,
1974 n_cell,
"CellToForgetWeights");
1976 if ( m_CellToOutputWeights )
1978 ValidateTensorNumDimNumElem(m_CellToOutputWeights->GetTensorInfo(), 1,
1979 n_cell,
"CellToOutputWeights");
1983 bool peephole_weights_all_or_none =
1984 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
1985 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
1986 || ( !m_CellToInputWeights && !m_CellToForgetWeights
1987 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
1988 if (!peephole_weights_all_or_none)
1994 if (m_Parameters.m_CifgEnabled)
1996 if (m_InputGateBias)
2003 if (!m_InputGateBias)
2006 "must be present.");
2008 ValidateTensorNumDimNumElem(m_InputGateBias->GetTensorInfo(), 1,
2009 n_cell,
"InputGateBias");
2012 ValidatePointer(m_ForgetGateBias,
"Null pointer check",
"ForgetGateBias");
2013 ValidateTensorNumDimNumElem(m_ForgetGateBias->GetTensorInfo(), 1, n_cell,
"ForgetGateBias");
2015 ValidatePointer(m_CellBias,
"Null pointer check",
"CellBias");
2016 ValidateTensorNumDimNumElem(m_CellBias->GetTensorInfo(), 1, n_cell,
"CellBias");
2018 ValidatePointer(m_OutputGateBias,
"Null pointer check",
"OutputGateBias");
2019 ValidateTensorNumDimNumElem(m_OutputGateBias->GetTensorInfo(), 1, n_cell,
"OutputGateBias");
2021 if (m_ProjectionWeights)
2023 ValidateTensorNumDimNumElem(m_ProjectionWeights->GetTensorInfo(), 2,
2024 (n_cell * n_output),
"ProjectionWeights");
2026 if (m_ProjectionBias)
2028 ValidateTensorNumDimNumElem(m_ProjectionBias->GetTensorInfo(), 1, n_output,
"ProjectionBias");
2035 bool projecton_tensors_consistent = ((!m_ProjectionWeights && !m_ProjectionBias &&
2036 !m_Parameters.m_ProjectionEnabled)
2037 || (m_ProjectionWeights && !m_ProjectionBias &&
2038 m_Parameters.m_ProjectionEnabled)
2039 || (m_ProjectionWeights && m_ProjectionBias &&
2040 m_Parameters.m_ProjectionEnabled));
2041 if (!projecton_tensors_consistent)
2050 if (m_InputLayerNormWeights)
2052 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"InputLayerNormWeights");
2054 if (m_ForgetLayerNormWeights)
2056 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2058 if (m_CellLayerNormWeights)
2060 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2062 if (m_OutputLayerNormWeights)
2064 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2067 if (m_Parameters.m_LayerNormEnabled)
2069 if (!m_Parameters.m_CifgEnabled)
2071 if (!m_InputLayerNormWeights)
2074 "disabled but InputLayerNormWeights are not present");
2076 ValidateTensorNumDimNumElem(m_InputLayerNormWeights->GetTensorInfo(),
2077 1, n_cell,
"InputLayerNormWeights");
2079 else if (m_InputLayerNormWeights)
2085 ValidatePointer(m_ForgetLayerNormWeights,
"Null pointer check layer normalisation enabled",
2086 "ForgetLayerNormWeights");
2087 ValidateTensorNumDimNumElem(m_ForgetLayerNormWeights->GetTensorInfo(), 1, n_cell,
"ForgetLayerNormWeights");
2089 ValidatePointer(m_OutputLayerNormWeights,
"Null pointer check layer normalisation enabled",
2090 "OutputLayerNormWeights");
2091 ValidateTensorNumDimNumElem(m_OutputLayerNormWeights->GetTensorInfo(), 1, n_cell,
"OutputLayerNormWeights");
2093 ValidatePointer(m_CellLayerNormWeights,
"Null pointer check layer normalisation enabled",
2094 "CellLayerNormWeights");
2095 ValidateTensorNumDimNumElem(m_CellLayerNormWeights->GetTensorInfo(), 1, n_cell,
"CellLayerNormWeights");
2097 else if (m_InputLayerNormWeights || m_ForgetLayerNormWeights || m_OutputLayerNormWeights || m_CellLayerNormWeights)
2100 "normalisation weights are present.");
2106 const std::string descriptorName{
"ConvertBf16ToFp32QueueDescriptor"};
2108 ValidateNumInputs(workloadInfo, descriptorName, 1);
2109 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2124 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2129 const std::string descriptorName{
"ConvertFp32ToBf16QueueDescriptor"};
2131 ValidateNumInputs(workloadInfo, descriptorName, 1);
2132 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2147 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2152 const std::string descriptorName{
"ConvertFp32ToFp16QueueDescriptor"};
2154 ValidateNumInputs(workloadInfo, descriptorName, 1);
2155 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2170 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2175 const std::string descriptorName{
"ConvertFp16ToFp32QueueDescriptor"};
2177 ValidateNumInputs(workloadInfo, descriptorName, 1);
2178 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2193 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2198 const std::string descriptorName{
"DivisionQueueDescriptor"};
2200 ValidateNumInputs(workloadInfo, descriptorName, 2);
2201 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2207 std::vector<DataType> supportedTypes =
2218 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2219 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2220 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2222 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2232 const std::string descriptorName{
"SubtractionQueueDescriptor"};
2234 ValidateNumInputs(workloadInfo, descriptorName, 2);
2235 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2241 std::vector<DataType> supportedTypes =
2252 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2253 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2254 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2256 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2266 const std::string descriptorName{
"MaximumQueueDescriptor"};
2268 ValidateNumInputs(workloadInfo, descriptorName, 2);
2269 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2275 std::vector<DataType> supportedTypes =
2286 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2287 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2288 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2290 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2300 const std::string descriptorName{
"MeanQueueDescriptor"};
2302 ValidateNumInputs(workloadInfo, descriptorName, 1);
2303 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2308 std::vector<DataType> supportedTypes =
2320 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2321 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2323 if (m_Parameters.m_KeepDims)
2325 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2327 else if (m_Parameters.m_Axis.empty())
2329 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
2333 unsigned int outputDim =
2335 ValidateTensorNumDimensions(outputTensorInfo,
2337 outputDim > 0 ? outputDim : 1,
2344 const std::string descriptorName{
"PadQueueDescriptor"};
2346 ValidateNumInputs(workloadInfo, descriptorName, 1);
2347 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2353 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, inputTensorInfo.
GetNumDimensions(),
"output");
2358 "as there are dimensions in the input tensor that is " +
2360 " not " + std::to_string(m_Parameters.m_PadList.size()) +
" entries.");
2366 const std::string descriptorName{
"QuantizeQueueDescriptor"};
2368 ValidateNumInputs(workloadInfo, descriptorName, 1);
2369 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2374 std::vector<DataType> supportedTypes =
2385 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2395 const std::string descriptorName{
"BatchToSpaceNdQueueDescriptor"};
2397 ValidateNumInputs(workloadInfo, descriptorName, 1);
2398 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2403 std::vector<DataType> supportedTypes =
2413 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2414 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2419 const std::string descriptorName{
"StridedSliceQueueDescriptor"};
2421 ValidateNumInputs(workloadInfo, descriptorName, 1);
2422 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2427 std::vector<DataType> supportedTypes =
2437 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2438 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2440 ValidateTensorQuantizationSpace(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2449 if (m_Parameters.m_Begin.size() != rank)
2454 if (m_Parameters.m_End.size() != rank)
2459 if (m_Parameters.m_Stride.size() != rank)
2465 for (
auto& stride : m_Parameters.m_Stride)
2476 const std::string descriptorName{
"MinimumQueueDescriptor"};
2478 ValidateNumInputs(workloadInfo, descriptorName, 2);
2479 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2485 std::vector<DataType> supportedTypes =
2496 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2497 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2498 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2500 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2510 const std::string descriptorName{
"DebugQueueDescriptor"};
2512 ValidateNumInputs(workloadInfo, descriptorName, 1);
2513 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2518 const std::string descriptorName{
"EqualQueueDescriptor"};
2520 ValidateNumInputs(workloadInfo, descriptorName, 2);
2521 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2527 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2542 const std::string descriptorName{
"GreaterQueueDescriptor"};
2544 ValidateNumInputs(workloadInfo, descriptorName, 2);
2545 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2551 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
2566 const std::string descriptorName{
"RsqrtQueueDescriptor"};
2568 ValidateNumInputs(workloadInfo, descriptorName, 1);
2569 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2574 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2576 std::vector<DataType> supportedTypes =
2586 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2587 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2592 const std::string descriptorName{
"GatherQueueDescriptor"};
2594 ValidateNumInputs(workloadInfo, descriptorName, 2);
2595 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2606 std::vector<DataType> supportedTypes =
2617 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2619 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2622 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, outputDim,
"output");
2627 const std::string& descriptorName{
"DetectionPostProcessQueueDescriptor"};
2629 ValidateNumInputs(workloadInfo, descriptorName, 2);
2637 if (m_Anchors ==
nullptr)
2651 ValidateTensorNumDimensions(boxEncodingsInfo, descriptorName, 3,
"box encodings");
2652 ValidateTensorNumDimensions(scoresInfo, descriptorName, 3,
"scores");
2653 ValidateTensorNumDimensions(anchorsInfo, descriptorName, 2,
"anchors");
2655 const std::vector<DataType> supportedInputTypes =
2665 ValidateDataTypes(boxEncodingsInfo, supportedInputTypes, descriptorName);
2666 ValidateDataTypes(scoresInfo, supportedInputTypes, descriptorName);
2667 ValidateDataTypes(anchorsInfo, supportedInputTypes, descriptorName);
2669 ValidateTensorNumDimensions(detectionBoxesInfo, descriptorName, 3,
"detection boxes");
2670 ValidateTensorNumDimensions(detectionScoresInfo, descriptorName, 2,
"detection scores");
2671 ValidateTensorNumDimensions(detectionClassesInfo, descriptorName, 2,
"detection classes");
2672 ValidateTensorNumDimensions(numDetectionsInfo, descriptorName, 1,
"num detections");
2675 ValidateTensorDataType(detectionBoxesInfo,
DataType::Float32, descriptorName,
"detection boxes");
2676 ValidateTensorDataType(detectionScoresInfo,
DataType::Float32, descriptorName,
"detection scores");
2677 ValidateTensorDataType(detectionClassesInfo,
DataType::Float32, descriptorName,
"detection classes");
2678 ValidateTensorDataType(numDetectionsInfo,
DataType::Float32, descriptorName,
"num detections");
2680 if (m_Parameters.m_NmsIouThreshold <= 0.0f || m_Parameters.m_NmsIouThreshold > 1.0f)
2683 "must be positive and less than or equal to 1.");
2686 if (scoresInfo.
GetShape()[2] != m_Parameters.m_NumClasses + 1)
2689 "should be equal to number of classes + 1.");
2695 const std::string& descriptorName{
"DequantizeQueueDescriptor"};
2697 ValidateNumInputs(workloadInfo, descriptorName, 1);
2698 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2708 std::vector<DataType> supportedTypes =
2715 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2720 const std::string& descriptorName{
"MergeQueueDescriptor"};
2722 ValidateNumInputs(workloadInfo, descriptorName, 2);
2723 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2729 ValidateTensorShapesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2730 ValidateTensorShapesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2732 ValidateTensorDataTypesMatch(inputTensorInfo0, inputTensorInfo1, descriptorName,
"input_0",
"input_1");
2733 ValidateTensorDataTypesMatch(inputTensorInfo0, outputTensorInfo, descriptorName,
"input_0",
"output");
2738 const std::string& descriptorName{
"SwitchQueueDescriptor"};
2740 ValidateNumInputs(workloadInfo, descriptorName, 2);
2741 ValidateNumOutputs(workloadInfo, descriptorName, 2);
2749 std::vector<DataType> supportedTypes =
2758 ValidateDataTypes(inputTensorInfo0, supportedTypes, descriptorName);
2759 ValidateDataTypes(inputTensorInfo1, supportedTypes, descriptorName);
2761 ValidateDataTypes(outputTensorInfo0, supportedTypes, descriptorName);
2762 ValidateDataTypes(outputTensorInfo1, supportedTypes, descriptorName);
2764 ValidateTensorShapesMatch(inputTensorInfo0,
2770 ValidateTensorShapesMatch(inputTensorInfo0,
2784 const std::string& descriptorName{
"PreluQueueDescriptor"};
2786 ValidateNumInputs(workloadInfo, descriptorName, 2);
2787 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2793 std::vector<DataType> supportedTypes
2803 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2804 ValidateDataTypes(alphaTensorInfo, supportedTypes, descriptorName);
2806 ValidateDataTypes(outputTensorInfo, supportedTypes, descriptorName);
2808 ValidateTensorDataTypesMatch(inputTensorInfo, alphaTensorInfo, descriptorName,
"input",
"alpha");
2809 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"ouptut");
2811 ValidateBroadcastTensorShapesMatch(inputTensorInfo,
2821 const std::string descriptorName{
"TransposeConvolution2dQueueDescriptor"};
2823 ValidateNumInputs(workloadInfo, descriptorName, 1);
2824 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2829 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, 4,
"input");
2830 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4,
"output");
2832 ValidatePointer(m_Weight, descriptorName,
"weight");
2834 const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
2835 ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4,
"weight");
2837 ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
2840 if (m_Parameters.m_BiasEnabled)
2842 ValidatePointer(m_Bias, descriptorName,
"bias");
2844 optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
2848 ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
2851 ValidatePerAxisQuantization(inputTensorInfo,
2854 optionalBiasTensorInfo,
2857 std::vector<DataType> supportedTypes =
2867 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
2868 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2873 const std::string descriptorName{
"TransposeQueueDescriptor"};
2875 ValidateNumInputs(workloadInfo, descriptorName, 1);
2876 ValidateNumOutputs(workloadInfo, descriptorName, 1);
2883 ValidateTensorNumDimensions(inputTensorInfo, descriptorName, mapping.
GetSize(),
"input");
2884 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, mapping.
GetSize(),
"output");
2886 for (
unsigned int i = 0u; i < mapping.
GetSize(); ++i)
2888 if (inputTensorInfo.
GetShape()[mapping[i]] != outputTensorInfo.
GetShape()[i])
2891 " (=" + to_string(inputTensorInfo.
GetShape()[mapping[i]]) +
") " +
2892 "must match dst dimension " + to_string(i) +
2893 " (=" + to_string(outputTensorInfo.
GetShape()[i]) +
")");
2897 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
2902 const std::string descriptorName{
"QLstmQueueDescriptor"};
2905 ValidateNumInputs(workloadInfo, descriptorName, 3);
2906 ValidateNumOutputs(workloadInfo, descriptorName, 3);
2918 std::vector<DataType> inputOutputSupportedTypes =
2923 std::vector<DataType> cellStateSupportedTypes =
2928 std::vector<DataType> weightsSupportedTypes =
2933 std::vector<DataType> layerNormPeepholeWeightsSupportedTypes =
2938 std::vector<DataType> biasSupportedTypes =
2944 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
2945 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
2946 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
2948 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
2949 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
2950 ValidateDataTypes(outputInfo, inputOutputSupportedTypes, descriptorName);
2953 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
2954 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
2955 "outputStateIn",
"outputStateOut");
2956 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
2959 const uint32_t numBatches = inputInfo.GetShape()[0];
2960 const uint32_t inputSize = inputInfo.GetShape()[1];
2961 const uint32_t outputSize = outputStateInInfo.GetShape()[1];
2962 const uint32_t numUnits = cellStateInInfo.GetShape()[1];
2965 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
2966 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
2967 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateIn");
2969 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
2970 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * numUnits), descriptorName +
" cellStateOut");
2971 ValidateTensorNumDimNumElem(outputInfo, 2, (numBatches * outputSize), descriptorName +
" output");
2974 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
2975 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
2976 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (numUnits * inputSize),
" InputToForgetWeights");
2978 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
2979 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
2980 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (numUnits * inputSize),
" InputToCellWeights");
2982 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
2983 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
2984 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (numUnits * inputSize),
" InputToOutputWeights");
2986 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
2987 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
2988 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (numUnits * outputSize),
2989 " RecurrentToForgetWeights");
2991 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
2992 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
2993 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
2995 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
2996 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
2997 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (numUnits * outputSize),
" RecurrentToCellWeights");
3000 ValidateDataTypes(inputToForgetWeightsInfo, weightsSupportedTypes, descriptorName);
3002 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToCellWeightsInfo, descriptorName,
3003 "inputToForgetWeights",
"inputToCellWeights");
3004 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3005 "inputToForgetWeights",
"inputToOutputWeights");
3007 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3008 "inputToForgetWeights",
"recurrentToForgeteights");
3009 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3010 "inputToForgetWeights",
"recurrentToCellWeights");
3011 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3012 "inputToForgetWeights",
"recurrentToOutputWeights");
3015 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3016 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3017 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, numUnits,
" ForgetGateBias");
3019 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3020 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3021 ValidateTensorNumDimNumElem(cellBiasInfo, 1, numUnits,
" CellBias");
3023 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3024 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3025 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, numUnits,
" OutputGateBias");
3028 ValidateDataTypes(forgetGateBiasInfo, biasSupportedTypes, descriptorName);
3030 ValidateTensorDataTypesMatch(forgetGateBiasInfo, cellBiasInfo, descriptorName,
3031 "forgetGateBias",
"cellBias");
3032 ValidateTensorDataTypesMatch(forgetGateBiasInfo, outputGateBiasInfo, descriptorName,
3033 "forgetGateBias",
"outputGateBias");
3036 const bool allCifgParamsPresentOrNot = ((m_InputToInputWeights && m_RecurrentToInputWeights && m_InputGateBias &&
3037 !m_Parameters.m_CifgEnabled) ||
3038 (!m_InputToInputWeights && !m_RecurrentToInputWeights &&
3039 !m_InputGateBias && m_Parameters.m_CifgEnabled));
3041 if (!allCifgParamsPresentOrNot)
3044 ": InputToInputWeights, RecurrentToInputWeights and InputGateBias must either all be present " 3045 "(CIFG disabled) or not be present at all (CIFG enabled). m_Parameters.m_CifgEnabled should be " 3046 "set appropriately.");
3049 if (!m_Parameters.m_CifgEnabled)
3052 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3053 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (numUnits * inputSize),
" InputToInputWeights");
3055 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3056 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (numUnits * outputSize),
3057 " RecurrentToInputWeights");
3059 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3060 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, numUnits,
" InputGateBias");
3063 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, inputToInputWeightsInfo, descriptorName,
3064 "inputToForgetWeights",
"inputToInputWeights");
3065 ValidateTensorDataTypesMatch(inputToForgetWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3066 "inputToForgetWeights",
"recurrentToInputWeights");
3067 ValidateTensorDataTypesMatch(forgetGateBiasInfo, inputGateBiasInfo, descriptorName,
3068 "forgetGateBias",
"inputGateBias");
3072 bool allPeepholeWeightsPresentOrNot =
3073 (((m_CellToInputWeights || m_Parameters.m_CifgEnabled) && m_CellToForgetWeights
3074 && m_CellToOutputWeights && m_Parameters.m_PeepholeEnabled)
3075 || (!m_CellToInputWeights && !m_CellToForgetWeights
3076 && !m_CellToOutputWeights && !m_Parameters.m_PeepholeEnabled));
3078 if (!allPeepholeWeightsPresentOrNot)
3081 ": CellToInputWeights, CellToForgetWeights and CellToOutputWeights should all be present (Peephole " 3082 "enabled) or not be present at all (Peephole disabled). CellToInputWeights should only be present " 3083 "when Peephole is enabled and CIFG is disabled. m_Parameters.m_PeepholeEnabled should be set " 3087 if (m_Parameters.m_PeepholeEnabled)
3089 auto cellToForgetWeightsInfo = m_CellToForgetWeights->GetTensorInfo();
3090 ValidateTensorNumDimNumElem(cellToForgetWeightsInfo, 1, numUnits,
" cellToForgetWeights");
3091 ValidateDataTypes(cellToForgetWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3093 auto cellToOutputWeightsInfo = m_CellToOutputWeights->GetTensorInfo();
3094 ValidateTensorNumDimNumElem(cellToOutputWeightsInfo, 1, numUnits,
" cellToOutputWeights");
3095 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToOutputWeightsInfo, descriptorName,
3096 "cellToForgetWeight",
"cellToOutputWeights");
3098 if (!m_Parameters.m_CifgEnabled)
3100 auto cellToInputWeightsInfo = m_CellToInputWeights->GetTensorInfo();
3101 ValidateTensorNumDimNumElem(cellToInputWeightsInfo, 1, numUnits,
" cellToInputWeights");
3102 ValidateTensorDataTypesMatch(cellToForgetWeightsInfo, cellToInputWeightsInfo, descriptorName,
3103 "cellToForgetWeights",
"cellToInputWeights");
3108 bool allLayerNormWeightsPresentOrNot =
3109 (((m_InputLayerNormWeights || m_Parameters.m_CifgEnabled) && m_ForgetLayerNormWeights
3110 && m_CellLayerNormWeights && m_OutputLayerNormWeights && m_Parameters.m_LayerNormEnabled)
3111 || (!m_InputLayerNormWeights && !m_ForgetLayerNormWeights && !m_CellLayerNormWeights
3112 && !m_OutputLayerNormWeights && !m_Parameters.m_LayerNormEnabled));
3114 if (!allLayerNormWeightsPresentOrNot)
3117 ": InputLayerNormWeights, ForgetLayerNormWeights, m_OutputLayerNormWeights " 3118 "and CellLayerNormWeights should all be present (Layer Norm enabled) or not " 3119 "be present at all (Layer Norm disabled). InputLayerNormWeights should " 3120 "only be present when Layer Norm is enabled and CIFG is disabled. " 3121 "m_Parameters.m_LayerNormEnabled should be set appropriately.");
3124 if (m_Parameters.m_LayerNormEnabled)
3126 auto forgetLayerNormWeightsInfo = m_ForgetLayerNormWeights->GetTensorInfo();
3127 ValidateTensorNumDimNumElem(forgetLayerNormWeightsInfo, 1, numUnits,
" forgetLayerNormWeights");
3128 ValidateDataTypes(forgetLayerNormWeightsInfo, layerNormPeepholeWeightsSupportedTypes, descriptorName);
3130 auto cellLayerNormWeightsInfo = m_CellLayerNormWeights->GetTensorInfo();
3131 ValidateTensorNumDimNumElem(cellLayerNormWeightsInfo, 1, numUnits,
" cellLayerNormWeights");
3132 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, cellLayerNormWeightsInfo, descriptorName,
3133 "forgetLayerNormWeights",
"cellLayerNormWeights");
3135 auto outputLayerNormWeightsInfo = m_OutputLayerNormWeights->GetTensorInfo();
3136 ValidateTensorNumDimNumElem(outputLayerNormWeightsInfo, 1, numUnits,
" outputLayerNormWeights");
3137 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, outputLayerNormWeightsInfo, descriptorName,
3138 "forgetLayerNormWeights",
"outputLayerNormWeights");
3140 if (!m_Parameters.m_CifgEnabled)
3142 auto inputLayerNormWeightsInfo = m_InputLayerNormWeights->GetTensorInfo();
3143 ValidateTensorNumDimNumElem(inputLayerNormWeightsInfo, 1, numUnits,
" inputLayerNormWeights");
3144 ValidateTensorDataTypesMatch(forgetLayerNormWeightsInfo, inputLayerNormWeightsInfo, descriptorName,
3145 "forgetLayerNormWeights",
"inputLayerNormWeights");
3150 bool correctProjectionTensorsPresent =
3151 ((!m_ProjectionWeights && !m_ProjectionBias && !m_Parameters.m_ProjectionEnabled) ||
3152 (m_ProjectionWeights && !m_ProjectionBias && m_Parameters.m_ProjectionEnabled) ||
3153 (m_ProjectionWeights && m_ProjectionBias && m_Parameters.m_ProjectionEnabled));
3155 if (!correctProjectionTensorsPresent)
3158 ": If projection is enabled, ProjectionWeights should be present and " 3159 "ProjectionBias is optional. If projection is disabled, neither " 3160 "ProjectionWeights nor ProjectionBias should be present.");
3163 if (m_Parameters.m_ProjectionEnabled)
3165 auto projectionWeightsInfo = m_ProjectionWeights->GetTensorInfo();
3166 ValidateTensorNumDimNumElem(projectionWeightsInfo, 2, (numUnits * outputSize),
"ProjectionWeights");
3167 ValidateDataTypes(projectionWeightsInfo, weightsSupportedTypes, descriptorName);
3169 if (m_ProjectionBias)
3171 auto projectionBiasInfo = m_ProjectionBias->GetTensorInfo();
3172 ValidateTensorNumDimNumElem(projectionBiasInfo, 1, outputSize,
"ProjectionBias");
3173 ValidateDataTypes(projectionBiasInfo, biasSupportedTypes, descriptorName);
3177 else if ((outputInfo.GetQuantizationScale() != m_Parameters.m_HiddenStateScale) &&
3178 outputInfo.GetQuantizationOffset() != m_Parameters.m_HiddenStateZeroPoint) {
3180 ": If projection is disabled, output quantization info (scale, offset) " 3181 "should match HiddenStateScale and HiddenStateZeroPoint.");
3188 const std::string descriptorName{
"QuantizedLstmQueueDescriptor"};
3191 ValidateNumInputs(workloadInfo, descriptorName, 3);
3192 ValidateNumOutputs(workloadInfo, descriptorName, 2);
3202 std::vector<DataType> inputOutputSupportedTypes =
3207 std::vector<DataType> cellStateSupportedTypes =
3212 std::vector<DataType> weightsSupportedTypes =
3217 std::vector<DataType> biasSupportedTypes =
3223 ValidateDataTypes(inputInfo, inputOutputSupportedTypes, descriptorName);
3224 ValidateDataTypes(cellStateInInfo, cellStateSupportedTypes, descriptorName);
3225 ValidateDataTypes(outputStateInInfo, inputOutputSupportedTypes, descriptorName);
3227 ValidateDataTypes(cellStateOutInfo, cellStateSupportedTypes, descriptorName);
3228 ValidateDataTypes(outputStateOutInfo, inputOutputSupportedTypes, descriptorName);
3231 ValidateTensorDataTypesMatch(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3232 ValidateTensorDataTypesMatch(outputStateInInfo, outputStateOutInfo, descriptorName,
3233 "outputStateIn",
"outputStateOut");
3234 ValidateTensorDataTypesMatch(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3237 ValidateTensorQuantizationSpace(inputInfo, outputStateInInfo, descriptorName,
"input",
"outputStateIn");
3238 ValidateTensorQuantizationSpace(inputInfo, outputStateOutInfo, descriptorName,
"input",
"outputStateOut");
3239 ValidateTensorQuantizationSpace(cellStateInInfo, cellStateOutInfo, descriptorName,
"cellStateIn",
"cellStateOut");
3242 const uint32_t numBatches = inputInfo.GetShape()[0];
3243 const uint32_t inputSize = inputInfo.GetShape()[1];
3244 const uint32_t outputSize = cellStateInInfo.GetShape()[1];
3247 ValidateTensorNumDimNumElem(inputInfo, 2, (numBatches * inputSize), descriptorName +
" input");
3248 ValidateTensorNumDimNumElem(cellStateInInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateIn");
3249 ValidateTensorNumDimNumElem(outputStateInInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateIn");
3250 ValidateTensorNumDimNumElem(cellStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" cellStateOut");
3251 ValidateTensorNumDimNumElem(outputStateOutInfo, 2, (numBatches * outputSize), descriptorName +
" outputStateOut");
3254 ValidatePointer(m_InputToInputWeights, descriptorName,
"InputToInputWeights");
3255 auto inputToInputWeightsInfo = m_InputToInputWeights->GetTensorInfo();
3256 ValidateTensorNumDimNumElem(inputToInputWeightsInfo, 2, (outputSize * inputSize),
" InputToInputWeights");
3258 ValidatePointer(m_InputToForgetWeights, descriptorName,
"InputToForgetWeights");
3259 auto inputToForgetWeightsInfo = m_InputToForgetWeights->GetTensorInfo();
3260 ValidateTensorNumDimNumElem(inputToForgetWeightsInfo, 2, (outputSize * inputSize),
" InputToForgetWeights");
3262 ValidatePointer(m_InputToCellWeights, descriptorName,
"InputToCellWeights");
3263 auto inputToCellWeightsInfo = m_InputToCellWeights->GetTensorInfo();
3264 ValidateTensorNumDimNumElem(inputToCellWeightsInfo, 2, (outputSize * inputSize),
" InputToCellWeights");
3266 ValidatePointer(m_InputToOutputWeights, descriptorName,
"InputToOutputWeights");
3267 auto inputToOutputWeightsInfo = m_InputToOutputWeights->GetTensorInfo();
3268 ValidateTensorNumDimNumElem(inputToOutputWeightsInfo, 2, (outputSize * inputSize),
" InputToOutputWeights");
3270 ValidatePointer(m_RecurrentToInputWeights, descriptorName,
"RecurrentToInputWeights");
3271 auto recurrentToInputWeightsInfo = m_RecurrentToInputWeights->GetTensorInfo();
3272 ValidateTensorNumDimNumElem(recurrentToInputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToInputWeights");
3274 ValidatePointer(m_RecurrentToForgetWeights, descriptorName,
"RecurrentToForgetWeights");
3275 auto recurrentToForgetWeightsInfo = m_RecurrentToForgetWeights->GetTensorInfo();
3276 ValidateTensorNumDimNumElem(recurrentToForgetWeightsInfo, 2, (outputSize * outputSize),
3277 " RecurrentToForgetWeights");
3279 ValidatePointer(m_RecurrentToCellWeights, descriptorName,
"RecurrentToCellWeights");
3280 auto recurrentToCellWeightsInfo = m_RecurrentToCellWeights->GetTensorInfo();
3281 ValidateTensorNumDimNumElem(recurrentToCellWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3283 ValidatePointer(m_RecurrentToOutputWeights, descriptorName,
"RecurrentToOutputWeights");
3284 auto recurrentToOutputWeightsInfo = m_RecurrentToOutputWeights->GetTensorInfo();
3285 ValidateTensorNumDimNumElem(recurrentToOutputWeightsInfo, 2, (outputSize * outputSize),
" RecurrentToCellWeights");
3288 ValidateDataTypes(inputToInputWeightsInfo, weightsSupportedTypes, descriptorName);
3290 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToForgetWeightsInfo, descriptorName,
3291 "inputToInputWeights",
"inputToForgetWeights");
3292 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToCellWeightsInfo, descriptorName,
3293 "inputToInputWeights",
"inputToCellWeights");
3294 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, inputToOutputWeightsInfo, descriptorName,
3295 "inputToInputWeights",
"inputToOutputWeights");
3297 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToInputWeightsInfo, descriptorName,
3298 "inputToInputWeights",
"recurrentToInputWeights");
3299 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToForgetWeightsInfo, descriptorName,
3300 "inputToInputWeights",
"recurrentToForgeteights");
3301 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToCellWeightsInfo, descriptorName,
3302 "inputToInputWeights",
"recurrentToCellWeights");
3303 ValidateTensorDataTypesMatch(inputToInputWeightsInfo, recurrentToOutputWeightsInfo, descriptorName,
3304 "inputToInputWeights",
"recurrentToOutputWeights");
3307 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToForgetWeightsInfo,
3308 descriptorName,
"inputToInputWeights",
"inputToForgetWeights");
3309 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToCellWeightsInfo,
3310 descriptorName,
"inputToInputWeights",
"inputToCellWeights");
3311 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, inputToOutputWeightsInfo,
3312 descriptorName,
"inputToInputWeights",
"inputToOutputWeights");
3314 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToInputWeightsInfo,
3315 descriptorName,
"inputToInputWeights",
"recurrentToInputWeights");
3316 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToForgetWeightsInfo,
3317 descriptorName,
"inputToInputWeights",
"recurrentToForgetWeights");
3318 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToCellWeightsInfo,
3319 descriptorName,
"inputToInputWeights",
"recurrentToCellWeights");
3320 ValidateTensorQuantizationSpace(inputToInputWeightsInfo, recurrentToOutputWeightsInfo,
3321 descriptorName,
"inputToInputWeights",
"recurrentToOutputWeights");
3324 ValidatePointer(m_InputGateBias, descriptorName,
"InputGateBias");
3325 auto inputGateBiasInfo = m_InputGateBias->GetTensorInfo();
3326 ValidateTensorNumDimNumElem(inputGateBiasInfo, 1, outputSize,
" InputGateBias");
3328 ValidatePointer(m_ForgetGateBias, descriptorName,
"ForgetGateBias");
3329 auto forgetGateBiasInfo = m_ForgetGateBias->GetTensorInfo();
3330 ValidateTensorNumDimNumElem(forgetGateBiasInfo, 1, outputSize,
" ForgetGateBias");
3332 ValidatePointer(m_CellBias, descriptorName,
"CellBias");
3333 auto cellBiasInfo = m_CellBias->GetTensorInfo();
3334 ValidateTensorNumDimNumElem(cellBiasInfo, 1, outputSize,
" CellBias");
3336 ValidatePointer(m_OutputGateBias, descriptorName,
"OutputGateBias");
3337 auto outputGateBiasInfo = m_OutputGateBias->GetTensorInfo();
3338 ValidateTensorNumDimNumElem(outputGateBiasInfo, 1, outputSize,
" OutputGateBias");
3341 ValidateDataTypes(inputGateBiasInfo, biasSupportedTypes, descriptorName);
3343 ValidateTensorDataTypesMatch(inputGateBiasInfo, forgetGateBiasInfo, descriptorName,
3344 "inputGateBias",
"forgetGateBias");
3345 ValidateTensorDataTypesMatch(inputGateBiasInfo, cellBiasInfo, descriptorName,
3346 "inputGateBias",
"cellBias");
3347 ValidateTensorDataTypesMatch(inputGateBiasInfo, outputGateBiasInfo, descriptorName,
3348 "inputGateBias",
"outputGateBias");
3351 ValidateBiasTensorQuantization(inputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3352 ValidateBiasTensorQuantization(forgetGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3353 ValidateBiasTensorQuantization(cellBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3354 ValidateBiasTensorQuantization(outputGateBiasInfo, inputInfo, inputToInputWeightsInfo, descriptorName);
3359 const std::string descriptorName{
"AbsQueueDescriptor"};
3361 ValidateNumInputs(workloadInfo, descriptorName, 1);
3362 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3367 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3369 std::vector<DataType> supportedTypes =
3380 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3381 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3386 const std::string descriptorName{
"SliceQueueDescriptor"};
3388 ValidateNumInputs(workloadInfo, descriptorName, 1);
3389 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3394 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3402 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, rank,
"output");
3405 if (m_Parameters.m_Begin.size() != rank)
3408 ": Length of begin offset descriptor must equal rank " + std::to_string(rank));
3410 if (m_Parameters.m_Size.size() != rank)
3413 ": Length of size descriptor must equal rank " + std::to_string(rank));
3418 for (
unsigned int i = 0u; i < rank; ++i)
3420 if (m_Parameters.m_Size[i] != outputShape[i])
3429 for(
unsigned int i = 0u; i < rank; ++i)
3431 if (m_Parameters.m_Begin[i] + m_Parameters.m_Size[i] > inputShape[i])
3434 std::to_string(i) +
" exceeds input size.");
3441 const std::string descriptorName{
"DepthToSpaceQueueDescriptor"};
3443 ValidateNumInputs(workloadInfo, descriptorName, 1);
3444 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3449 ValidateTensorNumDimensions(inputInfo, descriptorName, 4,
"input");
3450 ValidateTensorNumDimensions(outputInfo, descriptorName, 4,
"output");
3452 std::vector<DataType> supportedTypes =
3462 ValidateDataTypes(inputInfo, supportedTypes, descriptorName);
3463 ValidateDataTypes(outputInfo, supportedTypes, descriptorName);
3465 ValidateTensorNumElementsMatch(inputInfo, outputInfo, descriptorName,
"input",
"output");
3467 if (m_Parameters.m_BlockSize == 0)
3473 const unsigned int wIndex = dimensionIndices.
GetWidthIndex();
3478 if (outputShape[hIndex] % m_Parameters.m_BlockSize != 0 || outputShape[wIndex] % m_Parameters.m_BlockSize != 0)
3481 "must be divisible by block size.");
3485 if (inputShape[cIndex] % (m_Parameters.m_BlockSize * m_Parameters.m_BlockSize) != 0)
3488 "must be divisible by the square of block size." );
3494 const std::string descriptorName{
"ComparisonQueueDescriptor"};
3496 ValidateNumInputs(workloadInfo, descriptorName, 2);
3497 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3503 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
3518 const std::string descriptorName{
"ElementwiseUnaryQueueDescriptor"};
3520 ValidateNumInputs(workloadInfo, descriptorName, 1);
3521 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3526 ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3528 std::vector<DataType> supportedTypes =
3539 std::vector<DataType> logicalSupportedTypes =
3546 ValidateDataTypes(inputTensorInfo, logicalSupportedTypes, descriptorName);
3550 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3554 ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName,
"input",
"output");
3559 const std::string descriptorName{
"RankQueueDescriptor"};
3561 ValidateNumInputs(workloadInfo, descriptorName, 1);
3562 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3567 ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 1,
"output");
3568 ValidateTensorNumElements(outputTensorInfo, descriptorName, 1,
"output");
3570 std::vector<DataType> supportedTypes =
3582 ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
3583 ValidateDataTypes(outputTensorInfo, { DataType::Signed32 }, descriptorName);
3588 const std::string descriptorName{
"LogicalBinaryQueueDescriptor"};
3590 ValidateNumInputs(workloadInfo, descriptorName, 2);
3591 ValidateNumOutputs(workloadInfo, descriptorName, 1);
3597 ValidateBroadcastTensorShapesMatch(inputTensorInfo0,
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool IsTypeSpaceMatch(const TensorInfo &other) const
Check that the types are the same and, if quantize, that the quantization parameters are the same...
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetWidthIndex() const
std::vector< unsigned int > m_Origin
const TensorShape & GetShape() const
constexpr bool IsQuantizedType()
#define ARMNN_NO_DEPRECATE_WARN_BEGIN
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
bool HasPerAxisQuantization() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
Optional< unsigned int > GetQuantizationDim() const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
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
void Validate(const WorkloadInfo &workloadInfo) const
unsigned int GetUnsignedAxis(const unsigned int inputDimension, const int axis)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
std::vector< TensorInfo > m_OutputTensorInfos
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
DataType GetBiasDataType(DataType inputDataType)
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
void Validate(const WorkloadInfo &workloadInfo) const
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
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
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