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 QueueDescriptorWithParameters< DepthwiseConvolution2dDescriptor >
virtual	~QueueDescriptorWithParameters ()=default

Public Member Functions inherited from QueueDescriptor
virtual	~QueueDescriptor ()=default

void	ValidateTensorNumDimensions (const TensorInfo &tensor, std::string const &descName, unsigned int numDimensions, std::string const &tensorName) const

void	ValidateTensorNumDimNumElem (const TensorInfo &tensorInfo, unsigned int numDimension, unsigned int numElements, std::string const &tensorName) const

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

bool	m_AllowExpandedDims = false

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

	QueueDescriptorWithParameters (QueueDescriptorWithParameters const &)=default

QueueDescriptorWithParameters &	operator= (QueueDescriptorWithParameters const &)=default

Protected Member Functions inherited from QueueDescriptor
	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 247 of file WorkloadData.hpp.

Constructor & Destructor Documentation

◆ DepthwiseConvolution2dQueueDescriptor()

DepthwiseConvolution2dQueueDescriptor ( )

inline

Definition at line 249 of file WorkloadData.hpp.

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

Member Function Documentation

◆ Validate()

void Validate ( const WorkloadInfo & workloadInfo ) const

Definition at line 1412 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, QueueDescriptor::ValidateTensorNumDimensions(), and OptionalReferenceSwitch< std::is_reference< T >::value, T >::value().

 {
     const std::string descriptorName{"DepthwiseConvolution2dQueueDescriptor"};
 
     uint32_t numInputs = 2;
     if (m_Parameters.m_BiasEnabled)
     {
         numInputs = 3;
     }
 
     ValidateNumInputs(workloadInfo,  descriptorName, numInputs);
     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");
 
     const TensorInfo& weightTensorInfo = workloadInfo.m_InputTensorInfos[1];
     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));
     }
 
     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]));
     }
 
     const unsigned int channelIndex = (m_Parameters.m_DataLayout == DataLayout::NCHW) ? 1 : 3;
     const unsigned int numWeightOutputChannelsRefFormat = weightTensorInfo.GetShape()[3];
     const unsigned int numWeightOutputChannelsAclFormat = weightTensorInfo.GetShape()[1];
     const unsigned int numOutputChannels = outputTensorInfo.GetShape()[channelIndex];
 
     // Weights format has two valid options: [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] (CpuAcc/GpuAcc).
     bool validRefFormat = (numWeightOutputChannelsRefFormat == numOutputChannels);
     bool validAclFormat = (numWeightOutputChannelsAclFormat == numOutputChannels);
 
     if (!(validRefFormat || validAclFormat))
     {
         throw InvalidArgumentException(fmt::format(
             "{0}: The weight format in armnn is expected to be [1, H, W, Cout] (CpuRef) or [1, Cout, H, W] "
             "(CpuAcc/GpuAcc). But neither the 4th (CpuRef) or 2nd (CpuAcc/GpuAcc) dimension is 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]));
     }
 
     ValidateWeightDataType(inputTensorInfo, weightTensorInfo, descriptorName);
 
     Optional<TensorInfo> optionalBiasTensorInfo;
     if (m_Parameters.m_BiasEnabled)
     {
         optionalBiasTensorInfo = MakeOptional<TensorInfo>(workloadInfo.m_InputTensorInfos[2]);
         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");
 }