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	SelectiveQuantizer
struct	SelectiveQuantizer< T, false >
struct	SelectiveQuantizer< armnn::Half, false >
struct	SelectiveQuantizer< armnn::BFloat16, false >
struct	IsFloatingPointIterator
class	ModelAccuracyChecker
struct	ParserPrototxtFixture

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 17 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< T, Base >::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(), ConvertConstDequantisationLayersToConstLayersImpl::~ConvertConstDequantisationLayersToConstLayersImpl(), ConvertConstPermuteLayersToConstLayers::~ConvertConstPermuteLayersToConstLayers(), and TurboConvertConstDequantisationLayersToConstLayersImpl::~TurboConvertConstDequantisationLayersToConstLayersImpl().

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(), BatchMatMulQueueDescriptor::Validate(), and PermuteDepthwiseConv2dWeightsImpl::~PermuteDepthwiseConv2dWeightsImpl().

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, OriginsDescriptor::GetNumDimensions(), TensorInfo::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.