Depthwise Convolution 2D layer workload data. More...

#include <WorkloadData.hpp>

Inheritance diagram for DepthwiseConvolution2dQueueDescriptor:

Public Member Functions
	DepthwiseConvolution2dQueueDescriptor ()

void	Validate (const WorkloadInfo &workloadInfo) const

Public Member Functions inherited from QueueDescriptor
void	ValidateInputsOutputs (const std::string &descName, unsigned int numExpectedIn, unsigned int numExpectedOut) const

template<typename T >
const T *	GetAdditionalInformation () const

Public Attributes
const ConstTensorHandle *	m_Weight

const ConstTensorHandle *	m_Bias

Public Attributes inherited from QueueDescriptorWithParameters< DepthwiseConvolution2dDescriptor >
DepthwiseConvolution2dDescriptor	m_Parameters

Public Attributes inherited from QueueDescriptor
std::vector< ITensorHandle * >	m_Inputs

std::vector< ITensorHandle * >	m_Outputs

void *	m_AdditionalInfoObject

Additional Inherited Members
Protected Member Functions inherited from QueueDescriptorWithParameters< DepthwiseConvolution2dDescriptor >
	~QueueDescriptorWithParameters ()=default

	QueueDescriptorWithParameters ()=default

	QueueDescriptorWithParameters (QueueDescriptorWithParameters const &)=default

QueueDescriptorWithParameters &	operator= (QueueDescriptorWithParameters const &)=default

Protected Member Functions inherited from QueueDescriptor
	~QueueDescriptor ()=default

	QueueDescriptor ()

	QueueDescriptor (QueueDescriptor const &)=default

QueueDescriptor &	operator= (QueueDescriptor const &)=default

Detailed Description

Depthwise Convolution 2D layer workload data.

Note: The weights are in the format [1, H, W, I*M]. Where I is the input channel size, M the depthwise mutliplier and H, W is the height and width of the filter kernel. If per channel quantization is applied the weights will be quantized along the last dimension/axis (I*M) which corresponds to the output channel size. If per channel quantization is applied the weights tensor will have I*M scales, one for each dimension of the quantization axis. You have to be aware of this when reshaping the weights tensor. Splitting the I*M axis, e.g. [1, H, W, I*M] –> [H, W, I, M], won't work without taking care of the corresponding quantization scales. If there is no per channel quantization applied reshaping the weights tensor won't cause any issues. There are preconfigured permutation functions available here.

Definition at line 224 of file WorkloadData.hpp.

Constructor & Destructor Documentation

◆ DepthwiseConvolution2dQueueDescriptor()

DepthwiseConvolution2dQueueDescriptor ( )

inline

Definition at line 226 of file WorkloadData.hpp.

         : m_Weight(nullptr)
         , m_Bias(nullptr)
     {
     }

Member Function Documentation

◆ Validate()

void Validate ( const WorkloadInfo & workloadInfo ) const

Definition at line 1325 of file WorkloadData.cpp.

References armnn::BFloat16, armnn::Float16, armnn::Float32, armnn::GetBiasDataType(), TensorInfo::GetDataType(), TensorInfo::GetShape(), WorkloadInfo::m_InputTensorInfos, WorkloadInfo::m_OutputTensorInfos, armnn::NCHW, armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS16, and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

 {
     const std::string descriptorName{"DepthwiseConvolution2dQueueDescriptor"};
 
     ValidateNumInputs(workloadInfo,  descriptorName, 1);
     ValidateNumOutputs(workloadInfo, descriptorName, 1);
 
     const TensorInfo& inputTensorInfo  = workloadInfo.m_InputTensorInfos[0];
     const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
 
     ValidateTensorNumDimensions(inputTensorInfo,  descriptorName, 4, "input");
     ValidateTensorNumDimensions(outputTensorInfo, descriptorName, 4, "output");
 
     ValidatePointer(m_Weight, descriptorName, "weight");
 
     const TensorInfo& weightTensorInfo = m_Weight->GetTensorInfo();
     ValidateTensorNumDimensions(weightTensorInfo, descriptorName, 4, "weight");
 
     if (m_Parameters.m_DilationX < 1 || m_Parameters.m_DilationY < 1 )
     {
         throw InvalidArgumentException(
             fmt::format("{}: dilationX (provided {}) and dilationY (provided {}) "
                         "cannot be smaller than 1.",
                         descriptorName, m_Parameters.m_DilationX, m_Parameters.m_DilationX));
     }
 
     if (m_Parameters.m_StrideX <= 0 || m_Parameters.m_StrideY <= 0  )
     {
         throw InvalidArgumentException(
             fmt::format("{}: strideX (provided {}) and strideY (provided {}) "
                         "cannot be either negative or 0.",
                         descriptorName, m_Parameters.m_StrideX, m_Parameters.m_StrideY));
     }
 
     const unsigned int channelIndex = (m_Parameters.m_DataLayout == DataLayout::NCHW) ? 1 : 3;
 
     // Expected weight shape: [ 1, H, W, I*M ] - This shape does NOT depend on the data layout
     // inputChannels * channelMultiplier should be equal to outputChannels.
     const unsigned int numWeightOutputChannels = weightTensorInfo.GetShape()[3]; // I*M=Cout
     const unsigned int numOutputChannels       = outputTensorInfo.GetShape()[channelIndex];
     if (numWeightOutputChannels != numOutputChannels)
     {
         throw InvalidArgumentException(fmt::format(
             "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
             "But 4th dimension is not equal to Cout. Cout = {1} Provided weight shape: [{2}, {3}, {4}, {5}]",
             descriptorName,
             numOutputChannels,
             weightTensorInfo.GetShape()[0],
             weightTensorInfo.GetShape()[1],
             weightTensorInfo.GetShape()[2],
             weightTensorInfo.GetShape()[3]));
     }
     if (weightTensorInfo.GetShape()[0] != 1)
     {
         throw InvalidArgumentException(fmt::format(
                 "{0}: The weight format in armnn is expected to be [1, H, W, Cout]."
                 "But first dimension is not equal to 1. Provided weight shape: [{1}, {2}, {3}, {4}]",
                 descriptorName,
                 weightTensorInfo.GetShape()[0],
                 weightTensorInfo.GetShape()[1],
                 weightTensorInfo.GetShape()[2],
                 weightTensorInfo.GetShape()[3]));
     }
 
     ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
 
     Optional<TensorInfo> optionalBiasTensorInfo;
     if (m_Parameters.m_BiasEnabled)
     {
         ValidatePointer(m_Bias, descriptorName, "bias");
 
         optionalBiasTensorInfo = MakeOptional<TensorInfo>(m_Bias->GetTensorInfo());
         const TensorInfo& biasTensorInfo = optionalBiasTensorInfo.value();
 
         ValidateBiasTensorQuantization(biasTensorInfo, inputTensorInfo, weightTensorInfo, descriptorName);
         ValidateTensorDataType(biasTensorInfo, GetBiasDataType(inputTensorInfo.GetDataType()), descriptorName, "bias");
     }
     ValidatePerAxisQuantization(inputTensorInfo,
                                 outputTensorInfo,
                                 weightTensorInfo,
                                 optionalBiasTensorInfo,
                                 descriptorName);
 
     std::vector<DataType> supportedTypes =
     {
         DataType::BFloat16,
         DataType::Float16,
         DataType::Float32,
         DataType::QAsymmS8,
         DataType::QAsymmU8,
         DataType::QSymmS16
     };
 
     ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
     ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
 }