armnnUtils Namespace Reference

Namespaces
	Filesystem

Classes
class	DataLayoutIndexed
	Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout. More...
class	FloatingPointConverter
struct	IsFloatingPointIterator
class	ModelAccuracyChecker
struct	ParserPrototxtFixture
struct	SelectiveQuantizer
struct	SelectiveQuantizer< armnn::BFloat16, false >
struct	SelectiveQuantizer< armnn::Half, false >
struct	SelectiveQuantizer< T, false >

Typedefs
using	TContainer = mapbox::util::variant< std::vector< float >, std::vector< int >, std::vector< unsigned char >, std::vector< int8_t > >
using	LabelCategoryNames = std::vector< std::string >

Functions
template<typename T >
bool	CompatibleTypes (armnn::DataType)
bool	operator== (const armnn::DataLayout &dataLayout, const DataLayoutIndexed &indexed)
	Equality methods. More...
bool	operator== (const DataLayoutIndexed &indexed, const armnn::DataLayout &dataLayout)
bool	within_percentage_tolerance (float a, float b, float tolerancePercent=1.0f)
	Compare two floats and return true if their values are within a specified tolerance of each other. More...
armnn::TensorShape	Permuted (const armnn::TensorShape &srcShape, const armnn::PermutationVector &mappings)
armnn::TensorInfo	Permuted (const armnn::TensorInfo &info, const armnn::PermutationVector &mappings)
void	Permute (const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
template<typename T >
T	SelectiveQuantize (float value, float scale, int32_t offset)
template<typename T >
float	SelectiveDequantize (T value, float scale, int32_t offset)
template<typename T , typename FloatIt , typename std::enable_if< IsFloatingPointIterator< FloatIt >::value, int >::type = 0>
std::vector< T >	QuantizedVector (FloatIt first, FloatIt last, float qScale, int32_t qOffset)
template<typename T >
std::vector< T >	QuantizedVector (const std::vector< float > &array, float qScale=1.f, int32_t qOffset=0)
template<typename T >
std::vector< T >	QuantizedVector (std::initializer_list< float > array, float qScale=1.f, int32_t qOffset=0)
armnn::TensorShape	GetTensorShape (unsigned int numberOfBatches, unsigned int numberOfChannels, unsigned int height, unsigned int width, const armnn::DataLayout dataLayout)
armnn::TensorInfo	GetTensorInfo (unsigned int numberOfBatches, unsigned int numberOfChannels, unsigned int height, unsigned int width, const armnn::DataLayout dataLayout, const armnn::DataType dataType)
armnn::TensorInfo	GetTensorInfo (unsigned int numberOfBatches, unsigned int numberOfChannels, unsigned int depth, unsigned int height, unsigned int width, const armnn::DataLayout dataLayout, const armnn::DataType dataType)
std::pair< float, float >	FindMinMax (armnn::ITensorHandle *tensorHandle)
armnn::TensorShape	ReduceDims (const armnn::TensorShape &tensorInfo, unsigned int dimensions)
armnn::TensorInfo	ReduceDims (const armnn::TensorInfo &tensorInfo, unsigned int dimensions)
armnn::TensorShape	ExpandDims (const armnn::TensorShape &tensorShape, int axis)
armnn::TensorShape	ExpandDimsToRank (const armnn::TensorShape &tensorShape, unsigned int rank)
std::vector< unsigned int >	SqueezeDims (const armnn::TensorShape &tensorShape)
unsigned int	GetNumElementsBetween (const armnn::TensorShape &shape, unsigned int firstAxisInclusive, unsigned int lastAxisExclusive)
unsigned int	GetUnsignedAxis (const unsigned int inputDimension, const int axis)
unsigned int	GetNumElementsAfter (const armnn::TensorShape &shape, unsigned int axis)
std::pair< unsigned int, std::vector< float > >	GetPerAxisParams (const armnn::TensorInfo &info)
template<typename PrimitiveType >
std::unique_ptr< float[]>	ToFloatArray (const std::vector< PrimitiveType > &data, const armnn::TensorInfo &tensorInfo)
std::unique_ptr< float[]>	ToFloatArray (const std::vector< uint8_t > &data, const armnn::TensorInfo &tensorInfo)
armnn::TensorShape	TransposeTensorShape (const armnn::TensorShape &srcShape, const armnn::PermutationVector &mappings)
armnn::TensorInfo	TransposeTensorShape (const armnn::TensorInfo &info, const armnn::PermutationVector &mappings)
void	Transpose (const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
template<>
bool	CompatibleTypes< float > (DataType dataType)
template<>
bool	CompatibleTypes< Half > (DataType dataType)
template<>
bool	CompatibleTypes< BFloat16 > (DataType dataType)
template<>
bool	CompatibleTypes< uint8_t > (DataType dataType)
template<>
bool	CompatibleTypes< int8_t > (DataType dataType)
template<>
bool	CompatibleTypes< int16_t > (DataType dataType)
template<>
bool	CompatibleTypes< int32_t > (DataType dataType)
template<>
bool	CompatibleTypes< int64_t > (DataType dataType)
template<typename TNodeId , typename TTargetNodes >
bool	GraphTopologicalSort (const TTargetNodes &targetNodes, std::function< std::vector< TNodeId >(TNodeId)> getIncomingEdges, std::vector< TNodeId > &outSorted)
std::vector< std::string >	SplitBy (const std::string &originalString, const std::string &delimiter=" ", bool includeEmptyToken=false)
	Split a string into tokens by a delimiter. More...
std::string	Strip (const std::string &originalString, const std::string &characterSet=" ")
	Remove any preceding and trailing character specified in the characterSet. More...
void	ProcessConcatInputTensorInfo (armnn::TensorInfo &inputTensorInfo, armnn::OriginsDescriptor &concatDescriptor, const unsigned int &concatAxis, unsigned int inputIndex, unsigned int &mergeDimOrigin)
void	CalculateReducedOutputTensoInfo (const armnn::TensorInfo &inputTensorInfo, const std::set< unsigned int > &axisSet, bool keepDims, armnn::TensorInfo &outputTensorInfo)
	Creates a tensor info after reducing the dimensions mentioned in axisData. More...
void	CalculateStridedSliceOutputTensorInfo (const armnn::TensorInfo &inputTensorInfo, const armnn::StridedSliceDescriptor &desc, armnn::TensorInfo &outputTensorInfo)
	Create output tensor info for a StridedSlice operator. More...
std::string	ConvertInt32ToOctalString (int value)
	Converts an int value into the Prototxt octal representation. More...
std::string	ConvertTensorShapeToString (const armnn::TensorShape &shape)
	Converts an TensorShape into Prototxt representation. More...
template<typename TContainer >
armnn::InputTensors	MakeInputTensors (const std::vector< armnn::BindingPointInfo > &inputBindings, const std::vector< TContainer > &inputDataContainers)
template<typename TContainer >
armnn::OutputTensors	MakeOutputTensors (const std::vector< armnn::BindingPointInfo > &outputBindings, std::vector< TContainer > &outputDataContainers)
template<typename PrimitiveType >
void	CheckSizes (const std::vector< PrimitiveType > &data, const armnn::TensorInfo &tensorInfo, unsigned int size=1)
void	CheckValidSize (std::initializer_list< size_t > validInputCounts, size_t actualValue, const char *validExpr, const char *actualExpr, const CheckLocation &location)
uint32_t	NonNegative (const char *expr, int32_t value, const CheckLocation &location)
int32_t	VerifyInt32 (const char *expr, int64_t value, const armnn::CheckLocation &location)

Variables
const armnn::PermutationVector	NHWCToArmNN = { 0, 2, 3, 1 }
const armnn::PermutationVector	ArmNNToNHWC = { 0, 3, 1, 2 }

Typedef Documentation

LabelCategoryNames

using LabelCategoryNames = std::vector<std::string>

Definition at line 25 of file ModelAccuracyChecker.hpp.

TContainer

using TContainer = mapbox::util::variant<std::vector<float>, std::vector<int>, std::vector<unsigned char>, std::vector<int8_t> >

Definition at line 18 of file TContainer.hpp.

Function Documentation

CalculateReducedOutputTensoInfo()

void CalculateReducedOutputTensoInfo	(	const armnn::TensorInfo &	inputTensorInfo,
		const std::set< unsigned int > &	axisSet,
		bool	keepDims,
		armnn::TensorInfo &	outputTensorInfo
	)

Creates a tensor info after reducing the dimensions mentioned in axisData.

Definition at line 52 of file ParserHelper.cpp.

{
    std::vector<unsigned int> outputShapeVector;
    bool dimensionFound = false;
    unsigned int size = 1;
 
    for (unsigned int i = 0; i < inputTensorInfo.GetNumDimensions(); ++i)
    {
        dimensionFound = false;
        for (unsigned int axis: axisSet)
        {
            if (axis == i)
            {
                dimensionFound = true;
                break;
            }
        }
 
        if (!dimensionFound)
        {
            size *= inputTensorInfo.GetShape()[i];
 
            if (keepDims)
            {
                outputShapeVector.push_back(inputTensorInfo.GetShape()[i]);
            }
        }
        else
        {
            if (keepDims)
            {
                outputShapeVector.push_back(1);
            }
        }
    }
 
    if (keepDims)
    {
        armnn::TensorShape outputTensorShape(inputTensorInfo.GetNumDimensions(), &outputShapeVector[0]);
        outputTensorInfo = armnn::TensorInfo(outputTensorShape, inputTensorInfo.GetDataType());
    }
    else
    {
        outputTensorInfo = armnn::TensorInfo({size}, inputTensorInfo.GetDataType());
    }
}

References TensorInfo::GetDataType(), TensorInfo::GetNumDimensions(), and TensorInfo::GetShape().

CalculateStridedSliceOutputTensorInfo()

void CalculateStridedSliceOutputTensorInfo	(	const armnn::TensorInfo &	inputTensorInfo,
		const armnn::StridedSliceDescriptor &	desc,
		armnn::TensorInfo &	outputTensorInfo
	)

Create output tensor info for a StridedSlice operator.

Definition at line 103 of file ParserHelper.cpp.

{
    const armnn::TensorShape& inputShape = inputTensorInfo.GetShape();
 
    std::vector<unsigned int> outputShapeVector;
    for (unsigned int i = 0; i < inputTensorInfo.GetNumDimensions(); i++)
    {
        if (desc.m_ShrinkAxisMask & (1 << i))
        {
            continue;
        }
 
        int stride = desc.m_Stride[i];
        int start = desc.GetStartForAxis(inputShape, i);
        int stop = desc.GetStopForAxis(inputShape, i, start);
 
        int newSize = stride > 0 ? ((stop - start) + stride - 1) / stride :
                      ((start - stop) - stride - 1) / -stride;
 
        newSize = std::max(0, newSize);
 
        outputShapeVector.push_back(static_cast<unsigned int>(newSize));
    }
 
    armnn::TensorShape outputTensorShape(inputTensorInfo.GetNumDimensions(), &outputShapeVector[0]);
    outputTensorInfo = armnn::TensorInfo(armnn::TensorShape(outputTensorShape), inputTensorInfo.GetDataType());
}

References TensorInfo::GetDataType(), TensorInfo::GetNumDimensions(), TensorInfo::GetShape(), StridedSliceDescriptor::GetStartForAxis(), StridedSliceDescriptor::GetStopForAxis(), StridedSliceDescriptor::m_ShrinkAxisMask, and StridedSliceDescriptor::m_Stride.

CheckSizes()

void armnnUtils::CheckSizes	(	const std::vector< PrimitiveType > &	data,
		const armnn::TensorInfo &	tensorInfo,
		unsigned int	size = 1
	)

Definition at line 296 of file TensorUtils.cpp.

{
    if (data.size() / size != tensorInfo.GetNumElements())
    {
        throw InvalidArgumentException(
                fmt::format("The data does not contain the expected number of elements {} != {}. {}",
                            data.size(), tensorInfo.GetNumElements(), CHECK_LOCATION().AsString()));
    }
}

References CHECK_LOCATION, and TensorInfo::GetNumElements().

Referenced by ToFloatArray().

CheckValidSize()

void CheckValidSize	(	std::initializer_list< size_t >	validInputCounts,
		size_t	actualValue,
		const char *	validExpr,
		const char *	actualExpr,
		const CheckLocation &	location
	)

Definition at line 16 of file VerificationHelpers.cpp.

{
    bool isValid = std::any_of(validInputCounts.begin(),
                               validInputCounts.end(),
                               [&actualValue](size_t x) { return x == actualValue; } );
    if (!isValid)
    {
        throw ParseException(fmt::format("{} = {} is not valid, not in {{}}. {}",
                                         actualExpr,
                                         actualValue,
                                         validExpr,
                                         location.AsString()));
    }
}

References CheckLocation::AsString().

CompatibleTypes()

bool CompatibleTypes

(

armnn::DataType

)

Definition at line 17 of file CompatibleTypes.cpp.

{
    return false;
}

CompatibleTypes< BFloat16 >()

bool armnnUtils::CompatibleTypes< BFloat16 >

(

DataType

dataType

)

Definition at line 35 of file CompatibleTypes.cpp.

{
    return dataType == DataType::BFloat16;
}

References armnn::BFloat16.

CompatibleTypes< float >()

bool armnnUtils::CompatibleTypes< float >

(

DataType

dataType

)

Definition at line 23 of file CompatibleTypes.cpp.

{
    return dataType == DataType::Float32;
}

References armnn::Float32.

CompatibleTypes< Half >()

bool armnnUtils::CompatibleTypes< Half >

(

DataType

dataType

)

Definition at line 29 of file CompatibleTypes.cpp.

{
    return dataType == DataType::Float16;
}

References armnn::Float16.

CompatibleTypes< int16_t >()

bool armnnUtils::CompatibleTypes< int16_t >

(

DataType

dataType

)

Definition at line 54 of file CompatibleTypes.cpp.

{
    return dataType == DataType::QSymmS16;
}

References armnn::QSymmS16.

CompatibleTypes< int32_t >()

bool armnnUtils::CompatibleTypes< int32_t >

(

DataType

dataType

)

Definition at line 60 of file CompatibleTypes.cpp.

{
    return dataType == DataType::Signed32;
}

References armnn::Signed32.

CompatibleTypes< int64_t >()

bool armnnUtils::CompatibleTypes< int64_t >

(

DataType

dataType

)

Definition at line 66 of file CompatibleTypes.cpp.

{
    return dataType == DataType::Signed64;
}

References armnn::Signed64.

CompatibleTypes< int8_t >()

bool armnnUtils::CompatibleTypes< int8_t >

(

DataType

dataType

)

Definition at line 47 of file CompatibleTypes.cpp.

{
    return dataType == DataType::QSymmS8
        || dataType == DataType::QAsymmS8;
}

References armnn::QAsymmS8, and armnn::QSymmS8.

CompatibleTypes< uint8_t >()

bool armnnUtils::CompatibleTypes< uint8_t >

(

DataType

dataType

)

Definition at line 41 of file CompatibleTypes.cpp.

{
    return dataType == DataType::Boolean || dataType == DataType::QAsymmU8;
}

References armnn::Boolean, and armnn::QAsymmU8.

ConvertInt32ToOctalString()

std::string ConvertInt32ToOctalString

(

int

value

)

Converts an int value into the Prototxt octal representation.

Definition at line 17 of file PrototxtConversions.cpp.

{
    std::stringstream ss;
    std::string returnString;
    for (int i = 0; i < 4; ++i)
    {
        ss << "\\";
        ss << std::setw(3) << std::setfill('0') << std::oct << ((value >> (i * 8)) & 0xFF);
    }
 
    ss >> returnString;
    return returnString;
}

ConvertTensorShapeToString()

std::string ConvertTensorShapeToString

(

const armnn::TensorShape &

shape

)

Converts an TensorShape into Prototxt representation.

Definition at line 32 of file PrototxtConversions.cpp.

{
    std::stringstream ss;
    for (unsigned int i = 0 ; i < shape.GetNumDimensions() ; i++)
    {
        ss << "dim {\n";
        ss << "size: " << std::to_string(shape[i]) << "\n";
        ss << "}\n";
    }
    return ss.str();
 
}

References TensorShape::GetNumDimensions().

ExpandDims()

TensorShape ExpandDims	(	const armnn::TensorShape &	tensorShape,
		int	axis
	)

Definition at line 142 of file TensorUtils.cpp.

{
    unsigned int outputDim = tensorShape.GetNumDimensions() + 1;
 
    if (axis < -armnn::numeric_cast<int>(outputDim) || axis > armnn::numeric_cast<int>(tensorShape.GetNumDimensions()))
    {
        throw InvalidArgumentException(fmt::format("Invalid expansion axis {} for {}D input tensor. {}",
                                                   axis,
                                                   tensorShape.GetNumDimensions(),
                                                   CHECK_LOCATION().AsString()));
    }
 
    if (axis < 0)
    {
        axis = armnn::numeric_cast<int>(outputDim) + axis;
    }
 
    std::vector<unsigned int> outputShape;
    outputShape.reserve(tensorShape.GetNumDimensions());
    for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
    {
        outputShape.push_back(tensorShape[i]);
    }
    outputShape.insert(outputShape.begin() + axis, 1);
 
    return { outputDim, outputShape.data() };
}

References CHECK_LOCATION, and TensorShape::GetNumDimensions().

ExpandDimsToRank()

TensorShape ExpandDimsToRank	(	const armnn::TensorShape &	tensorShape,
		unsigned int	rank
	)

Definition at line 170 of file TensorUtils.cpp.

{
    // Can't expand if rank is smaller than current shape
    if (tensorShape.GetNumDimensions() >= rank)
    {
        return tensorShape;
    }
 
    std::vector<unsigned int> newShape;
 
    // First add 1s to the beginning of the tensorInfo to fill in the space
    for (unsigned int i = 0; i < rank - tensorShape.GetNumDimensions(); ++i)
    {
        newShape.push_back(1);
    }
 
    // Then iterate through the original shape and append it to the new shape with the added 1s
    for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
    {
        newShape.push_back(tensorShape[i]);
    }
 
    return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
}

References TensorShape::GetNumDimensions().

FindMinMax()

std::pair< float, float > FindMinMax

(

armnn::ITensorHandle *

tensorHandle

)

Definition at line 81 of file TensorUtils.cpp.

{
    auto tensor_data = static_cast<const float *>(tensorHandle->Map(true));
    auto tensor_size = tensorHandle->GetShape().GetNumElements();
 
    // Set min/max initially to first value in tensor
    float min = tensor_data[0];
    float max = tensor_data[0];
 
    // Loop over rest of tensor and update min/max if necessary
    for (unsigned int val = 1; val < tensor_size; val++)
    {
        if (tensor_data[val] < min)
        {
            min = tensor_data[val];
        }
        else if (tensor_data[val] > max)
        {
            max = tensor_data[val];
        }
    }
 
    tensorHandle->Unmap();
 
    return std::make_pair(min, max);
}

References TensorShape::GetNumElements(), ITensorHandle::GetShape(), ITensorHandle::Map(), and ITensorHandle::Unmap().

GetNumElementsAfter()

unsigned int GetNumElementsAfter	(	const armnn::TensorShape &	shape,
		unsigned int	axis
	)

Definition at line 261 of file TensorUtils.cpp.

{
    unsigned int numDim = shape.GetNumDimensions();
    if (axis >= numDim)
    {
        throw armnn::InvalidArgumentException(fmt::format(
            "{}: axis index [{}D] indexes beyond the number of dimesions of the tensor shape [{}D]",
            "GetNumElementsAfter",
            axis,
            numDim));
    }
    unsigned int count = 1;
    for (unsigned int i = axis+1; i < numDim; i++)
    {
        count *= shape[i];
    }
    return count;
}

References TensorShape::GetNumDimensions().

Referenced by GetPerAxisParams(), PerAxisIterator< const int8_t, Decoder< float > >::PerAxisIterator(), and ToFloatArray().

GetNumElementsBetween()

unsigned int GetNumElementsBetween	(	const armnn::TensorShape &	shape,
		unsigned int	firstAxisInclusive,
		unsigned int	lastAxisExclusive
	)

Definition at line 209 of file TensorUtils.cpp.

{
    if (firstAxisInclusive > lastAxisExclusive)
    {
        throw armnn::InvalidArgumentException(fmt::format(
            "GetNumElementsBetween: firstAxisInclusive [{}D] is greater than lastAxisExclusive [{}D]",
            firstAxisInclusive,
            lastAxisExclusive));
    }
    if (lastAxisExclusive > shape.GetNumDimensions())
    {
        throw armnn::InvalidArgumentException(fmt::format(
            "{}: lastAxisExclusive [{}D] is greater than the number of dimensions of the tensor shape [{}D]"
            "GetNumElementsBetween",
            lastAxisExclusive,
            shape.GetNumDimensions()));
    }
    unsigned int count = 1;
    for (unsigned int i = firstAxisInclusive; i < lastAxisExclusive; i++)
    {
        count *= shape[i];
    }
    return count;
}

References TensorShape::GetNumDimensions().

Referenced by armnn::ArgMinMax(), armnn::LogSoftmax(), and armnn::Softmax().

GetPerAxisParams()

std::pair< unsigned int, std::vector< float > > GetPerAxisParams

(

const armnn::TensorInfo &

info

)

Definition at line 280 of file TensorUtils.cpp.

{
    const std::vector<float>& scales = info.GetQuantizationScales();
    armnn::Optional<unsigned int> quantizationDim = info.GetQuantizationDim();
    if (!info.HasPerAxisQuantization())
    {
        throw armnn::InvalidArgumentException(
            std::string("Per-axis quantization params not set for tensor of type ") +
            armnn::GetDataTypeName(info.GetDataType()), CHECK_LOCATION());
    }
    unsigned int axisFactor = GetNumElementsAfter(info.GetShape(), quantizationDim.value()) ;
 
    return { axisFactor, scales };
}

References CHECK_LOCATION, armnn::GetDataTypeName(), GetNumElementsAfter(), armnn::info, and OptionalReferenceSwitch< IsReference, T >::value().

Referenced by armnn::MakeEncoder().

GetTensorInfo() [1/2]

TensorInfo GetTensorInfo	(	unsigned int	numberOfBatches,
		unsigned int	numberOfChannels,
		unsigned int	depth,
		unsigned int	height,
		unsigned int	width,
		const armnn::DataLayout	dataLayout,
		const armnn::DataType	dataType
	)

Definition at line 60 of file TensorUtils.cpp.

{
    switch (dataLayout)
    {
        case DataLayout::NDHWC:
            return TensorInfo({numberOfBatches, depth, height, width, numberOfChannels}, dataType);
        case DataLayout::NCDHW:
            return TensorInfo({numberOfBatches, numberOfChannels, depth, height, width}, dataType);
        default:
            throw InvalidArgumentException("Unknown data layout ["
                                                  + std::to_string(static_cast<int>(dataLayout)) +
                                                  "]", CHECK_LOCATION());
    }
}

References CHECK_LOCATION, armnn::NCDHW, and armnn::NDHWC.

GetTensorInfo() [2/2]

TensorInfo GetTensorInfo	(	unsigned int	numberOfBatches,
		unsigned int	numberOfChannels,
		unsigned int	height,
		unsigned int	width,
		const armnn::DataLayout	dataLayout,
		const armnn::DataType	dataType
	)

Definition at line 40 of file TensorUtils.cpp.

{
    switch (dataLayout)
    {
        case DataLayout::NCHW:
            return TensorInfo({numberOfBatches, numberOfChannels, height, width}, dataType);
        case DataLayout::NHWC:
            return TensorInfo({numberOfBatches, height, width, numberOfChannels}, dataType);
        default:
            throw InvalidArgumentException("Unknown data layout ["
                                                  + std::to_string(static_cast<int>(dataLayout)) +
                                                  "]", CHECK_LOCATION());
    }
}

References CHECK_LOCATION, armnn::NCHW, and armnn::NHWC.

GetTensorShape()

TensorShape GetTensorShape	(	unsigned int	numberOfBatches,
		unsigned int	numberOfChannels,
		unsigned int	height,
		unsigned int	width,
		const armnn::DataLayout	dataLayout
	)

Definition at line 21 of file TensorUtils.cpp.

{
    switch (dataLayout)
    {
        case DataLayout::NCHW:
            return TensorShape({numberOfBatches, numberOfChannels, height, width});
        case DataLayout::NHWC:
            return TensorShape({numberOfBatches, height, width, numberOfChannels});
        default:
            throw InvalidArgumentException("Unknown data layout ["
                                                  + std::to_string(static_cast<int>(dataLayout)) +
                                                  "]", CHECK_LOCATION());
    }
}

References CHECK_LOCATION, armnn::NCHW, and armnn::NHWC.

GetUnsignedAxis()

unsigned int GetUnsignedAxis	(	const unsigned int	inputDimension,
		const int	axis
	)

Definition at line 236 of file TensorUtils.cpp.

{
    if (axis >= armnn::numeric_cast<int>(inputDimension))
    {
        throw armnn::InvalidArgumentException(fmt::format(
            "{}: axis index [{}] is not less than the number of dimensions [{}D]",
            "GetUnsignedAxis",
            axis,
            inputDimension));
    }
    if (axis < -armnn::numeric_cast<int>(inputDimension))
    {
        throw armnn::InvalidArgumentException(fmt::format(
            "{}: axis index [{}] lower than the negative of the number of dimensions [{}]",
            "GetUnsignedAxis",
            axis,
            -armnn::numeric_cast<int>(inputDimension)));
    }
 
    unsigned int uAxis = axis < 0  ?
                         inputDimension - armnn::numeric_cast<unsigned int>(abs(axis))
                         : armnn::numeric_cast<unsigned int>(axis);
    return uAxis;
}

Referenced by armnn::ArgMinMax(), ClArgMinMaxWorkload::ClArgMinMaxWorkload(), armnn::ComputeSplitAxis(), ArgMinMaxLayer::InferOutputShapes(), NeonArgMinMaxWorkload::NeonArgMinMaxWorkload(), and ArgMinMaxQueueDescriptor::Validate().

GraphTopologicalSort()

bool armnnUtils::GraphTopologicalSort	(	const TTargetNodes &	targetNodes,
		std::function< std::vector< TNodeId >(TNodeId)>	getIncomingEdges,
		std::vector< TNodeId > &	outSorted
	)

Definition at line 110 of file GraphTopologicalSort.hpp.

{
    outSorted.clear();
    std::map<TNodeId, NodeState> nodeStates;
 
    for (TNodeId targetNode : targetNodes)
    {
        if (!TopologicallySort(targetNode, getIncomingEdges, outSorted, nodeStates))
        {
            return false;
        }
    }
 
    return true;
}

MakeInputTensors()

armnn::InputTensors armnnUtils::MakeInputTensors ( const std::vector< armnn::BindingPointInfo > &  inputBindings, const std::vector< TContainer > &  inputDataContainers  )

inline

Definition at line 17 of file TensorIOUtils.hpp.

{
    armnn::InputTensors inputTensors;
 
    const size_t numInputs = inputBindings.size();
    if (numInputs != inputDataContainers.size())
    {
        throw armnn::Exception(fmt::format("The number of inputs does not match number of "
                                           "tensor data containers: {0} != {1}",
                                           numInputs,
                                           inputDataContainers.size()));
    }
 
    for (size_t i = 0; i < numInputs; i++)
    {
        const armnn::BindingPointInfo& inputBinding = inputBindings[i];
        const TContainer& inputData = inputDataContainers[i];
 
        mapbox::util::apply_visitor([&](auto&& value)
        {
            if (value.size() != inputBinding.second.GetNumElements())
            {
               throw armnn::Exception(fmt::format("The input tensor has incorrect size (expected {0} got {1})",
                                                  inputBinding.second.GetNumElements(),
                                                  value.size()));
            }
            armnn::TensorInfo inputTensorInfo = inputBinding.second;
            inputTensorInfo.SetConstant(true);
            armnn::ConstTensor inputTensor(inputTensorInfo, value.data());
            inputTensors.push_back(std::make_pair(inputBinding.first, inputTensor));
        },
        inputData);
    }
 
    return inputTensors;
}

References TensorInfo::SetConstant().

MakeOutputTensors()

armnn::OutputTensors armnnUtils::MakeOutputTensors ( const std::vector< armnn::BindingPointInfo > &  outputBindings, std::vector< TContainer > &  outputDataContainers  )

inline

Definition at line 56 of file TensorIOUtils.hpp.

{
    armnn::OutputTensors outputTensors;
 
    const size_t numOutputs = outputBindings.size();
    if (numOutputs != outputDataContainers.size())
    {
        throw armnn::Exception(fmt::format("Number of outputs does not match number"
                                           "of tensor data containers: {0} != {1}",
                                           numOutputs,
                                           outputDataContainers.size()));
    }
 
    for (size_t i = 0; i < numOutputs; i++)
    {
        const armnn::BindingPointInfo& outputBinding = outputBindings[i];
        TContainer& outputData = outputDataContainers[i];
 
        mapbox::util::apply_visitor([&](auto&& value)
        {
            if (value.size() != outputBinding.second.GetNumElements())
            {
                throw armnn::Exception("Output tensor has incorrect size");
            }
 
            armnn::Tensor outputTensor(outputBinding.second, value.data());
            outputTensors.push_back(std::make_pair(outputBinding.first, outputTensor));
        },
        outputData);
    }
 
    return outputTensors;
}

NonNegative()

uint32_t NonNegative	(	const char *	expr,
		int32_t	value,
		const CheckLocation &	location
	)

Definition at line 35 of file VerificationHelpers.cpp.

{
    if (value < 0)
    {
        throw ParseException(fmt::format("'{}' must be non-negative, received: {} at {}",
                                         expr,
                                         value,
                                         location.AsString()));
    }
    else
    {
        return static_cast<uint32_t>(value);
    }
}

References CheckLocation::AsString().

operator==() [1/2]

bool operator==	(	const armnn::DataLayout &	dataLayout,
		const DataLayoutIndexed &	indexed
	)

Equality methods.

Definition at line 46 of file DataLayoutIndexed.cpp.

{
    return dataLayout == indexed.GetDataLayout();
}

References DataLayoutIndexed::GetDataLayout().

operator==() [2/2]

bool operator==	(	const DataLayoutIndexed &	indexed,
		const armnn::DataLayout &	dataLayout
	)

Definition at line 51 of file DataLayoutIndexed.cpp.

{
    return indexed.GetDataLayout() == dataLayout;
}

References DataLayoutIndexed::GetDataLayout().

Permute()

void Permute	(	const armnn::TensorShape &	dstShape,
		const armnn::PermutationVector &	mappings,
		const void *	src,
		void *	dst,
		size_t	dataTypeSize
	)

Definition at line 164 of file Permute.cpp.

{
    PermuteLoop(dstShape, mappings).Unroll(src, dst, dataTypeSize);
}

Referenced by armnnOnnxParser::CreateConstTensorImpl(), armnn::DepthToSpace(), PermuteLayer::PermuteLayer(), armnn::PermuteTensor(), and armnn_driver::SwizzleAndroidNn4dTensorToArmNn().

Permuted() [1/2]

armnn::TensorInfo Permuted	(	const armnn::TensorInfo &	info,
		const armnn::PermutationVector &	mappings
	)

Definition at line 148 of file Permute.cpp.

{
    armnn::TensorInfo outInfo(info);
    outInfo.SetShape(Permuted(info.GetShape(), mappings));
 
    // If TensorInfo has Per-Axis Quantization then it also has a QuantizationDim which needs to
    // be permuted according to the mapping
    if (info.GetQuantizationDim().has_value())
    {
        outInfo.SetQuantizationDim(mappings[info.GetQuantizationDim().value()]);
    }
 
    return outInfo;
}

References armnn::info, Permuted(), TensorInfo::SetQuantizationDim(), and TensorInfo::SetShape().

Permuted() [2/2]

armnn::TensorShape Permuted	(	const armnn::TensorShape &	srcShape,
		const armnn::PermutationVector &	mappings
	)

Definition at line 125 of file Permute.cpp.

{
    if (srcShape.GetNumDimensions() != mappings.GetSize())
    {
        std::stringstream msg;
        msg << "Permute: Number of shape dimensions (" << srcShape.GetNumDimensions() <<
               ") does not match the size of the mappings (" << mappings.GetSize() << ")";
        throw armnn::InvalidArgumentException(msg.str());
    }
 
    const unsigned int numDims = mappings.GetSize();
    unsigned int outDims[armnn::MaxNumOfTensorDimensions];
 
    for (unsigned int i = 0U; i < numDims; ++i)
    {
        outDims[mappings[i]] = srcShape[i];
    }
 
    armnn::TensorShape permutedShape(numDims, outDims);
    return permutedShape;
}

References TensorShape::GetNumDimensions(), PermutationVector::GetSize(), and armnn::MaxNumOfTensorDimensions.

Referenced by armnn::Convert1HWOTensorInfoToAcl(), armnn::ConvertWeightTensorInfoFromArmnnToAcl(), armnnOnnxParser::CreateConstTensorImpl(), BatchMatMulLayer::InferOutputShapes(), PermuteLayer::InferOutputShapes(), Permuted(), armnn::PermuteTensor(), MovePermuteUpImpl::Run(), armnn_driver::SwizzleAndroidNn4dTensorToArmNn(), and BatchMatMulQueueDescriptor::Validate().

ProcessConcatInputTensorInfo()

void ProcessConcatInputTensorInfo	(	armnn::TensorInfo &	inputTensorInfo,
		armnn::OriginsDescriptor &	concatDescriptor,
		const unsigned int &	concatAxis,
		unsigned int	inputIndex,
		unsigned int &	mergeDimOrigin
	)

Definition at line 19 of file ParserHelper.cpp.

{
    const uint32_t inputRank = concatDescriptor.GetNumDimensions();
 
    // double check dimensions of the tensors
    if (inputTensorInfo.GetNumDimensions() != inputRank)
    {
        throw armnn::ParseException(fmt::format(
                                    "The number of dimensions: {0} for input tensors of the "
                                    "concatenation op should be {1} {2}",
                                    inputTensorInfo.GetNumDimensions(),
                                    inputRank,
                                    CHECK_LOCATION().AsString()));
    }
 
    for (unsigned int j = 0; j < concatAxis; ++j)
    {
        concatDescriptor.SetViewOriginCoord(inputIndex, j, 0);
    }
 
    concatDescriptor.SetViewOriginCoord(inputIndex, concatAxis, mergeDimOrigin);
    mergeDimOrigin += inputTensorInfo.GetShape()[concatAxis];
 
    for (unsigned int j = concatAxis + 1; j < inputRank; ++j)
    {
        concatDescriptor.SetViewOriginCoord(inputIndex, j, 0);
    }
}

References CHECK_LOCATION, TensorInfo::GetNumDimensions(), OriginsDescriptor::GetNumDimensions(), TensorInfo::GetShape(), and OriginsDescriptor::SetViewOriginCoord().

QuantizedVector() [1/3]

std::vector<T> armnnUtils::QuantizedVector	(	const std::vector< float > &	array,
		float	qScale = 1.f,
		int32_t	qOffset = 0
	)

Definition at line 121 of file QuantizeHelper.hpp.

{
    return QuantizedVector<T>(array.begin(), array.end(), qScale, qOffset);
}

QuantizedVector() [2/3]

std::vector<T> armnnUtils::QuantizedVector	(	FloatIt	first,
		FloatIt	last,
		float	qScale,
		int32_t	qOffset
	)

Definition at line 105 of file QuantizeHelper.hpp.

{
    std::vector<T> quantized;
    quantized.reserve(armnn::numeric_cast<size_t>(std::distance(first, last)));
 
    for (auto it = first; it != last; ++it)
    {
        auto f = *it;
        T q = SelectiveQuantize<T>(f, qScale, qOffset);
        quantized.push_back(q);
    }
 
    return quantized;
}

QuantizedVector() [3/3]

std::vector<T> armnnUtils::QuantizedVector	(	std::initializer_list< float >	array,
		float	qScale = 1.f,
		int32_t	qOffset = 0
	)

Definition at line 127 of file QuantizeHelper.hpp.

{
    return QuantizedVector<T>(array.begin(), array.end(), qScale, qOffset);
}

ReduceDims() [1/2]

TensorInfo ReduceDims	(	const armnn::TensorInfo &	tensorInfo,
		unsigned int	dimensions
	)

Definition at line 134 of file TensorUtils.cpp.

{
    TensorInfo strippedTensor(tensorInfo);
    TensorShape strippedShape = ReduceDims(tensorInfo.GetShape(), dimensions);
    strippedTensor.SetShape(strippedShape);
    return strippedTensor;
}

References TensorInfo::GetShape(), ReduceDims(), and TensorInfo::SetShape().

ReduceDims() [2/2]

TensorShape ReduceDims	(	const armnn::TensorShape &	tensorInfo,
		unsigned int	dimensions
	)

Definition at line 108 of file TensorUtils.cpp.

{
    if (tensorShape.GetNumDimensions() <= dimensions)
    {
        return tensorShape;
    }
    std::vector<unsigned int> newShape;
 
    unsigned int dimsToSkip = tensorShape.GetNumDimensions() - dimensions;
    unsigned int dimsSkipped = 0;
    bool insertRemainder = false;
 
    for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
    {
        if (tensorShape[i] == 1 && dimsSkipped < dimsToSkip && !insertRemainder)
        {
            ++dimsSkipped;
            continue;
        }
        newShape.push_back(tensorShape[i]);
        // Once we insert the first dimension we can't skip any more
        insertRemainder = true;
    }
    return TensorShape(static_cast<unsigned int>(newShape.size()), newShape.data());
}

References TensorShape::GetNumDimensions().

Referenced by ReduceDims().

SelectiveDequantize()

float armnnUtils::SelectiveDequantize	(	T	value,
		float	scale,
		int32_t	offset
	)

Definition at line 91 of file QuantizeHelper.hpp.

{
    return SelectiveQuantizer<T, armnn::IsQuantizedType<T>()>::Dequantize(value, scale, offset);
};

SelectiveQuantize()

T armnnUtils::SelectiveQuantize	(	float	value,
		float	scale,
		int32_t	offset
	)

Definition at line 85 of file QuantizeHelper.hpp.

{
    return SelectiveQuantizer<T, armnn::IsQuantizedType<T>()>::Quantize(value, scale, offset);
};

SplitBy()

std::vector< std::string > SplitBy	(	const std::string &	originalString,
		const std::string &	delimiter = " ",
		bool	includeEmptyToken = false
	)

Split a string into tokens by a delimiter.

Parameters

[in]	originalString	Original string to be split
[in]	delimiter	Delimiter used to split originalString
[in]	includeEmptyToekn	If true, include empty tokens in the result

Returns

A vector of tokens split from originalString by \delimiter

Definition at line 41 of file ModelAccuracyChecker.cpp.

{
    std::vector<std::string> tokens;
    size_t cur  = 0;
    size_t next = 0;
    while ((next = originalString.find(delimiter, cur)) != std::string::npos)
    {
        // Skip empty tokens, unless explicitly stated to include them.
        if (next - cur > 0 || includeEmptyToken)
        {
            tokens.push_back(originalString.substr(cur, next - cur));
        }
        cur = next + delimiter.size();
    }
    // Get the remaining token
    // Skip empty tokens, unless explicitly stated to include them.
    if (originalString.size() - cur > 0 || includeEmptyToken)
    {
        tokens.push_back(originalString.substr(cur, originalString.size() - cur));
    }
    return tokens;
}

SqueezeDims()

std::vector< unsigned int > SqueezeDims

(

const armnn::TensorShape &

tensorShape

)

Definition at line 195 of file TensorUtils.cpp.

{
    std::vector<unsigned int> squeezedDims;
 
    for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
    {
        if (tensorShape[i] != 1)
        {
            squeezedDims.push_back(tensorShape[i]);
        }
    }
    return squeezedDims;
}

References TensorShape::GetNumDimensions().

Referenced by Layer::ValidateAndCopyShape().

Strip()

std::string Strip	(	const std::string &	originalString,
		const std::string &	characterSet = " "
	)

Remove any preceding and trailing character specified in the characterSet.

Parameters

[in]	originalString	Original string to be stripped
[in]	characterSet	Set of characters to be stripped from originalString

Returns

A string stripped of all characters specified in characterSet from originalString

Definition at line 65 of file ModelAccuracyChecker.cpp.

{
    if (characterSet.empty())
    {
        throw armnn::InvalidArgumentException("Strip: string of characters to strip is empty");
    }
    const std::size_t firstFound = originalString.find_first_not_of(characterSet);
    const std::size_t lastFound  = originalString.find_last_not_of(characterSet);
    // Return empty if the originalString is empty or the originalString contains only to-be-striped characters
    if (firstFound == std::string::npos || lastFound == std::string::npos)
    {
        return "";
    }
    return originalString.substr(firstFound, lastFound + 1 - firstFound);
}

ToFloatArray() [1/2]

std::unique_ptr< float[]> ToFloatArray	(	const std::vector< PrimitiveType > &	data,
		const armnn::TensorInfo &	tensorInfo
	)

Definition at line 307 of file TensorUtils.cpp.

{
    CheckSizes(data, tensorInfo);
 
    std::unique_ptr<float[]> returnBuffer(new float[tensorInfo.GetNumElements()]);
 
    if (tensorInfo.HasPerAxisQuantization())
    {
        unsigned int axis = tensorInfo.GetQuantizationDim().value();
        auto axisDimensionality = tensorInfo.GetShape()[axis];
        auto axisFactor = armnnUtils::GetNumElementsAfter(tensorInfo.GetShape(), axis);
 
        for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
        {
            unsigned int axisIndex;
 
            if (i < axisFactor)
            {
                axisIndex = 0;
            }
            else
            {
                axisIndex = (i / axisFactor) % axisDimensionality;
            }
            returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
                                                        tensorInfo.GetQuantizationScales()[axisIndex],
                                                        tensorInfo.GetQuantizationOffset());
        }
    }
    else
    {
        for (unsigned int i = 0; i < tensorInfo.GetNumElements(); ++i)
        {
            returnBuffer[i] = Dequantize<PrimitiveType>(data[i],
                                                        tensorInfo.GetQuantizationScale(),
                                                        tensorInfo.GetQuantizationOffset());
        }
    }
    return returnBuffer;
}

References CheckSizes(), TensorInfo::GetNumElements(), GetNumElementsAfter(), TensorInfo::GetQuantizationDim(), TensorInfo::GetQuantizationOffset(), TensorInfo::GetQuantizationScale(), TensorInfo::GetQuantizationScales(), TensorInfo::GetShape(), TensorInfo::HasPerAxisQuantization(), and OptionalReferenceSwitch< IsReference, T >::value().

ToFloatArray() [2/2]

std::unique_ptr< float[]> ToFloatArray	(	const std::vector< uint8_t > &	data,
		const armnn::TensorInfo &	tensorInfo
	)

Definition at line 348 of file TensorUtils.cpp.

{
    if (tensorInfo.GetDataType() == DataType::QAsymmS8 || tensorInfo.GetDataType() == DataType::QSymmS8)
    {
        CheckSizes(data, tensorInfo);
        std::vector<int8_t> buffer(tensorInfo.GetNumElements());
        ::memcpy(buffer.data(), data.data(), data.size());
        return ToFloatArray<int8_t>(buffer, tensorInfo);
    }
    else if (tensorInfo.GetDataType() == DataType::QAsymmU8)
    {
        CheckSizes(data, tensorInfo);
        return ToFloatArray<uint8_t>(data, tensorInfo);
    }
    else if (tensorInfo.GetDataType() == DataType::Signed32)
    {
        CheckSizes(data, tensorInfo, 4);
        std::vector<int32_t> buffer(tensorInfo.GetNumElements());
        ::memcpy(buffer.data(), data.data(), data.size());
        return ToFloatArray<int32_t>(buffer, tensorInfo);
    }
    else if (tensorInfo.GetDataType() == DataType::Signed64)
    {
        CheckSizes(data, tensorInfo, 8);
        std::vector<int64_t> buffer(tensorInfo.GetNumElements());
        ::memcpy(buffer.data(), data.data(), data.size());
        return ToFloatArray<int64_t>(buffer, tensorInfo);
    }
    throw InvalidArgumentException(
            fmt::format("Unsupported datatype {}. {}",
                        GetDataTypeName(tensorInfo.GetDataType()),
                        CHECK_LOCATION().AsString()));
}

References CHECK_LOCATION, CheckSizes(), TensorInfo::GetDataType(), armnn::GetDataTypeName(), TensorInfo::GetNumElements(), armnn::QAsymmS8, armnn::QAsymmU8, armnn::QSymmS8, armnn::Signed32, and armnn::Signed64.

Transpose()

void Transpose	(	const armnn::TensorShape &	dstShape,
		const armnn::PermutationVector &	mappings,
		const void *	src,
		void *	dst,
		size_t	dataTypeSize
	)

Definition at line 153 of file Transpose.cpp.

{
    TransposeLoop(srcShape, mappings).Unroll(src, dst, dataTypeSize);
}

Referenced by TransposeLayer::TransposeLayer().

TransposeTensorShape() [1/2]

armnn::TensorInfo TransposeTensorShape	(	const armnn::TensorInfo &	info,
		const armnn::PermutationVector &	mappings
	)

Definition at line 146 of file Transpose.cpp.

{
    armnn::TensorInfo outInfo(info);
    outInfo.SetShape(TransposeTensorShape(info.GetShape(), mappings));
    return outInfo;
}

References armnn::info, TensorInfo::SetShape(), and TransposeTensorShape().

TransposeTensorShape() [2/2]

armnn::TensorShape TransposeTensorShape	(	const armnn::TensorShape &	srcShape,
		const armnn::PermutationVector &	mappings
	)

Definition at line 125 of file Transpose.cpp.

{
    if (srcShape.GetNumDimensions() != mappings.GetSize())
    {
        std::stringstream msg;
        msg << "Transpose: Number of shape dimensions (" << srcShape.GetNumDimensions() <<
            ") does not match the size of the mappings (" << mappings.GetSize() << ")";
        throw armnn::InvalidArgumentException(msg.str());
    }
 
    const unsigned int numDims = mappings.GetSize();
    unsigned int outDims[armnn::MaxNumOfTensorDimensions];
 
    for (unsigned int i = 0U; i < numDims; ++i)
    {
        outDims[i] = srcShape[mappings[i]];
    }
    armnn::TensorShape permutedShape(numDims, outDims);
    return permutedShape;
}

References TensorShape::GetNumDimensions(), PermutationVector::GetSize(), and armnn::MaxNumOfTensorDimensions.

Referenced by TransposeLayer::InferOutputShapes(), MoveTransposeUpImpl::Run(), and TransposeTensorShape().

VerifyInt32()

int32_t VerifyInt32	(	const char *	expr,
		int64_t	value,
		const armnn::CheckLocation &	location
	)

Definition at line 52 of file VerificationHelpers.cpp.

{
    if (value < std::numeric_limits<int>::min()  || value > std::numeric_limits<int>::max())
    {
        throw ParseException(fmt::format("'{}' must should fit into a int32 (ArmNN don't support int64),"
                                         " received: {} at {}",
                                         expr,
                                         value,
                                         location.AsString()));
    }
    else
    {
        return static_cast<int32_t>(value);
    }
}

References CheckLocation::AsString().

within_percentage_tolerance()

bool armnnUtils::within_percentage_tolerance ( float  a, float  b, float  tolerancePercent = 1.0f  )

inline

Compare two floats and return true if their values are within a specified tolerance of each other.

Parameters

a
b
tolerancePercentage	If not supplied default will be 1% tolerance (1.0f)

Returns

true if the value of float b is within tolerancePercentage of the value for float a.

Definition at line 20 of file FloatingPointComparison.hpp.

{
    float toleranceValue = std::fabs(a * (tolerancePercent / 100));
    return std::fabs(a - b) <= toleranceValue;
}

Variable Documentation

ArmNNToNHWC

const armnn::PermutationVector ArmNNToNHWC = { 0, 3, 1, 2 }

Definition at line 17 of file ParserHelper.cpp.

NHWCToArmNN

const armnn::PermutationVector NHWCToArmNN = { 0, 2, 3, 1 }

Definition at line 16 of file ParserHelper.cpp.