+ + + + +

+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)

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<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.

+ +

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

+

 {
     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());
     }
 }

+
+
+
+
+

+

+ +

◆ 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.

+ +

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

+

 {
     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());
 }

+
+
+
+
+
+
+
+
+

+

+ +

◆ CheckSizes()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 237 of file TensorUtils.cpp.

+ +

References CHECK_LOCATION, and TensorInfo::GetNumElements().

+ +

Referenced by ToFloatArray().

+

 {
     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()));
     }
 }

+
+
+

+

+ +

◆ 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.

+ +

References CheckLocation::AsString().

+

 {
     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()));
     }
 }

+
+

+

+ +

◆ 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.

+ +

References armnn::BFloat16.

+

 {
     return dataType == DataType::BFloat16;
 }

+

+ +

◆ CompatibleTypes< float >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< float > ( DataType dataType )

+

+ +

Definition at line 23 of file CompatibleTypes.cpp.

+ +

References armnn::Float32.

+

 {
     return dataType == DataType::Float32;
 }

+

+ +

◆ CompatibleTypes< Half >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< Half > ( DataType dataType )

+

+ +

Definition at line 29 of file CompatibleTypes.cpp.

+ +

References armnn::Float16.

+

 {
     return dataType == DataType::Float16;
 }

+

+ +

◆ CompatibleTypes< int16_t >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< int16_t > ( DataType dataType )

+

+ +

Definition at line 54 of file CompatibleTypes.cpp.

+ +

References armnn::QSymmS16.

+

 {
     return dataType == DataType::QSymmS16;
 }

+

+ +

◆ CompatibleTypes< int32_t >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< int32_t > ( DataType dataType )

+

+ +

Definition at line 60 of file CompatibleTypes.cpp.

+ +

References armnn::Signed32.

+

 {
     return dataType == DataType::Signed32;
 }

+

+ +

◆ CompatibleTypes< int8_t >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< int8_t > ( DataType dataType )

+

+ +

Definition at line 47 of file CompatibleTypes.cpp.

+ +

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

+

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

+

+ +

◆ CompatibleTypes< uint8_t >()

+ +

+

+ + + + + + + + +

bool armnnUtils::CompatibleTypes< uint8_t > ( DataType dataType )

+

+ +

Definition at line 41 of file CompatibleTypes.cpp.

+ +

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

+

 {
     return dataType == DataType::Boolean || dataType == DataType::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.

+ +

References TensorShape::GetNumDimensions().

+

 {
     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();
 
 }

+

+

+ +

◆ ExpandDims()

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 140 of file TensorUtils.cpp.

+ +

References CHECK_LOCATION, TensorShape::GetNumDimensions(), and armnn::numeric_cast().

+ +

Referenced by Converter::ConvertOperation().

+

 {
     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() };
 }

+
+
+
+

+

+ +

◆ FindMinMax()

+ +

+

+ + + + + + + + +

std::pair< float, float > FindMinMax ( armnn::ITensorHandle * tensorHandle )

+

+ +

Definition at line 79 of file TensorUtils.cpp.

+ +

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

+

 {
     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);
 }

+
+
+
+

+

+ +

◆ GetNumElementsAfter()

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 209 of file TensorUtils.cpp.

+ +

References ARMNN_ASSERT, and TensorShape::GetNumDimensions().

+ +

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

+

 {
     unsigned int numDim = shape.GetNumDimensions();
     ARMNN_ASSERT(axis <= numDim - 1);
     unsigned int count = 1;
     for (unsigned int i = axis+1; i < numDim; i++)
     {
         count *= shape[i];
     }
     return count;
 }

+
+

+

+ +

◆ GetNumElementsBetween()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 182 of file TensorUtils.cpp.

+ +

References ARMNN_ASSERT, and TensorShape::GetNumDimensions().

+ +

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

+

 {
     ARMNN_ASSERT(firstAxisInclusive <= lastAxisExclusive);
     ARMNN_ASSERT(lastAxisExclusive <= shape.GetNumDimensions());
     unsigned int count = 1;
     for (unsigned int i = firstAxisInclusive; i < lastAxisExclusive; i++)
     {
         count *= shape[i];
     }
     return count;
 }

+
+

+

+ +

◆ GetPerAxisParams()

+ +

+

+ + + + + + + + +

std::pair< unsigned int, std::vector< float > > GetPerAxisParams ( const armnn::TensorInfo & info )

+

+ +

Definition at line 221 of file TensorUtils.cpp.

+ +

References CHECK_LOCATION, TensorInfo::GetDataType(), armnn::GetDataTypeName(), GetNumElementsAfter(), TensorInfo::GetQuantizationDim(), TensorInfo::GetQuantizationScales(), TensorInfo::GetShape(), TensorInfo::HasPerAxisQuantization(), and OptionalReferenceSwitch< IsReference, T >::value().

+ +

Referenced by armnn::MakeDecoder(), and armnn::MakeEncoder().

+

 {
     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 };
 }

+
+
+
+
+
+
+
+
+
+
+

+

+ +

◆ GetTensorInfo() [1/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 38 of file TensorUtils.cpp.

+ +

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

+

 {
     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());
     }
 }

+
+
+

+

+ +

◆ GetTensorInfo() [2/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 58 of file TensorUtils.cpp.

+ +

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

+

 {
     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());
     }
 }

+
+
+

+

+ +

◆ GetTensorShape()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 19 of file TensorUtils.cpp.

+ +

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

+

 {
     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());
     }
 }

+
+
+

+

+ +

◆ GetUnsignedAxis()

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 196 of file TensorUtils.cpp.

+ +

References ARMNN_ASSERT_MSG, and armnn::numeric_cast().

+ +

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

+

 {
     ARMNN_ASSERT_MSG(axis < armnn::numeric_cast<int>(inputDimension),
                      "Required axis index greater than number of dimensions.");
     ARMNN_ASSERT_MSG(axis >= -armnn::numeric_cast<int>(inputDimension),
                      "Required axis index lower than negative of the number of dimensions");
 
     unsigned int uAxis = axis < 0  ?
                          inputDimension - armnn::numeric_cast<unsigned int>(abs(axis))
                          : armnn::numeric_cast<unsigned int>(axis);
     return uAxis;
 }

+
+
+

+

+ +

◆ 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.

+ +

References TensorInfo::SetConstant().

+

 {
     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;
 }

+
+
+
+
+
+
+

+

+ +

◆ 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.

+ +

References CheckLocation::AsString().

+

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

+
+

+

+ +

◆ operator==() [1/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Equality methods.

+ +

Definition at line 46 of file DataLayoutIndexed.cpp.

+ +

References DataLayoutIndexed::GetDataLayout().

+ +

Referenced by OutputSlot::Disconnect(), and DataLayoutIndexed::GetIndex().

+

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

+

+

+ +

◆ operator==() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 51 of file DataLayoutIndexed.cpp.

+ +

References DataLayoutIndexed::GetDataLayout().

+

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

+

+

+ +

◆ Permute()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 131 of file Permute.cpp.

+ +

Referenced by armnnOnnxParser::CreateConstTensorImpl(), armnn::DepthToSpace(), IDeserializer::DeserializerImpl::GetNetworkOutputBindingInfo(), and PermuteLayer::PermuteLayer().

+

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

+

+ +

◆ Permuted() [1/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 98 of file Permute.cpp.

+ +

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

+ +

Referenced by BatchMatMul::BatchMatMul(), armnn::Convert1HWOTensorInfoToAcl(), armnn::ConvertWeightTensorInfoFromArmnnToAcl(), armnnOnnxParser::CreateConstTensorImpl(), OnnxParserImpl::CreateNetworkFromString(), RefUnidirectionalSequenceLstmWorkload::ExecuteAsync(), IDeserializer::DeserializerImpl::GetNetworkOutputBindingInfo(), BatchMatMulLayer::InferOutputShapes(), PermuteLayer::InferOutputShapes(), Permuted(), armnn::PermuteTensor(), PermuteDepthwiseConv2dWeightsImpl::Run(), MovePermuteUpImpl::Run(), armnn_driver::SwizzleAndroidNn4dTensorToArmNn(), and BatchMatMulQueueDescriptor::Validate().

+

 {
     assert(srcShape.GetNumDimensions() == mappings.GetSize());
 
     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;
 }

+
+
+
+

+

+ +

◆ Permuted() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 115 of file Permute.cpp.

+ +

References TensorInfo::GetQuantizationDim(), TensorInfo::GetShape(), OptionalBase::has_value(), Permuted(), TensorInfo::SetQuantizationDim(), TensorInfo::SetShape(), and OptionalReferenceSwitch< IsReference, T >::value().

+

 {
     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;
 }

+
+
+
+
+
+

+

+ +

◆ 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.

+ +

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

+ +

Referenced by OnnxParserImpl::CreateNetworkFromString(), and TfLiteParserImpl::OutputShapeOfReshape().

+

 {
     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);
     }
 }

+
+
+
+
+
+

+

+ +

◆ QuantizedVector() [1/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() [2/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() [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]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 106 of file TensorUtils.cpp.

+ +

References TensorShape::GetNumDimensions().

+ +

Referenced by ReduceDims().

+

 {
     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());
 }

+

+

+ +

◆ ReduceDims() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 132 of file TensorUtils.cpp.

+ +

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

+

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

+
+
+
+

+

+ +

◆ SelectiveDequantize()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 91 of file QuantizeHelper.hpp.

+ +

References SelectiveQuantizer< T, DoQuantize >::Dequantize().

+

 {
     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.

+ +

References SelectiveQuantizer< T, DoQuantize >::Quantize().

+

 {
     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

+ +

Definition at line 40 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 168 of file TensorUtils.cpp.

+ +

References TensorShape::GetNumDimensions().

+ +

Referenced by Layer::ValidateAndCopyShape().

+

 {
     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;
 }

+

+

+ +

◆ 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 64 of file ModelAccuracyChecker.cpp.

+ +

References ARMNN_ASSERT.

+

 {
     ARMNN_ASSERT(!characterSet.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 248 of file TensorUtils.cpp.

+ +

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

+ +

Referenced by TfLiteParserImpl::GetBuffer().

+

 {
     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;
 }

+
+
+
+
+
+
+
+
+
+

+

+ +

◆ ToFloatArray() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 289 of file TensorUtils.cpp.

+ +

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

+

 {
     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()));
 }

+
+
+
+
+
+

+

+ +

◆ Transpose()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 120 of file Transpose.cpp.

+ +

Referenced by TransposeLayer::TransposeLayer().

+

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

+

+ +

◆ TransposeTensorShape() [1/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 98 of file Transpose.cpp.

+ +

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

+ +

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

+

 {
     assert(srcShape.GetNumDimensions() == mappings.GetSize());
 
     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;
 }

+
+
+
+

+

+ +

◆ TransposeTensorShape() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 113 of file Transpose.cpp.

+ +

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

+

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

+
+
+

+

+ +

◆ VerifyInt32()

+ +

+

+ + + + + + + + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 52 of file VerificationHelpers.cpp.

+ +

References CheckLocation::AsString().

+

 {
     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);
     }
 }

+
+

+

+ +

◆ 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.

+ +

+

+Namespaces

+Classes

+Typedefs

+Functions

+Variables

Typedef Documentation

◆ LabelCategoryNames

◆ TContainer

Function Documentation

◆ CalculateReducedOutputTensoInfo()

◆ CalculateStridedSliceOutputTensorInfo()

◆ CheckSizes()

◆ CheckValidSize()

◆ CompatibleTypes()

◆ CompatibleTypes< BFloat16 >()

◆ CompatibleTypes< float >()

◆ CompatibleTypes< Half >()

◆ CompatibleTypes< int16_t >()

◆ CompatibleTypes< int32_t >()

◆ CompatibleTypes< int8_t >()

◆ CompatibleTypes< uint8_t >()

◆ ConvertInt32ToOctalString()

◆ ConvertTensorShapeToString()

◆ ExpandDims()

◆ FindMinMax()

◆ GetNumElementsAfter()

◆ GetNumElementsBetween()

◆ GetPerAxisParams()

◆ GetTensorInfo() [1/2]

◆ GetTensorInfo() [2/2]

◆ GetTensorShape()

◆ GetUnsignedAxis()

◆ GraphTopologicalSort()

◆ MakeInputTensors()

◆ MakeOutputTensors()

◆ NonNegative()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ Permute()

◆ Permuted() [1/2]

◆ Permuted() [2/2]

◆ ProcessConcatInputTensorInfo()

◆ QuantizedVector() [1/3]

◆ QuantizedVector() [2/3]

◆ QuantizedVector() [3/3]

◆ ReduceDims() [1/2]

◆ ReduceDims() [2/2]

◆ SelectiveDequantize()

◆ SelectiveQuantize()

◆ SplitBy()

◆ SqueezeDims()

◆ Strip()

◆ ToFloatArray() [1/2]

◆ ToFloatArray() [2/2]

◆ Transpose()

◆ TransposeTensorShape() [1/2]

◆ TransposeTensorShape() [2/2]

◆ VerifyInt32()

◆ within_percentage_tolerance()

Variable Documentation

◆ ArmNNToNHWC

◆ NHWCToArmNN