armnnUtils Namespace Reference

Namespaces
	Filesystem
	Processes

Classes
class	CsvReader
struct	CsvRow
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	LabelCategoryNames = std::vector< std::string >

Functions
bool	operator== (const armnn::DataLayout &dataLayout, const DataLayoutIndexed &indexed)
	Equality methods. More...
bool	operator== (const DataLayoutIndexed &indexed, const armnn::DataLayout &dataLayout)
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)
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)
std::pair< float, float >	FindMinMax (armnn::ITensorHandle *tensorHandle)
armnn::TensorShape	ExpandDims (const armnn::TensorShape &tensorShape, int axis)
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)
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)
CsvRow	ParseLine (const std::string &csvLine)
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 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)
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)
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.

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 54 of file ParserHelper.cpp.

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

Referenced by BOOST_AUTO_TEST_CASE(), and armnnTfParser::OutputShapeOfSqueeze().

{
    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 105 of file ParserHelper.cpp.

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

Referenced by armnnTfParser::OutputShapeOfSqueeze().

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

CheckValidSize()

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

Definition at line 15 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(
            boost::str(
                boost::format("%1% = %2% is not valid, not in {%3%}. %4%") %
                              actualExpr %
                              actualValue %
                              validExpr %
                              location.AsString()));
    }
}

ConvertInt32ToOctalString()

std::string ConvertInt32ToOctalString

(

int

value

)

Converts an int value into the Prototxt octal representation.

Definition at line 19 of file PrototxtConversions.cpp.

Referenced by BOOST_AUTO_TEST_CASE().

{
    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 34 of file PrototxtConversions.cpp.

References TensorShape::GetNumDimensions().

Referenced by BOOST_AUTO_TEST_CASE().

{
    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 85 of file TensorUtils.cpp.

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

Referenced by BOOST_AUTO_TEST_CASE().

{
    unsigned int outputDim = tensorShape.GetNumDimensions() + 1;

    if (axis < -boost::numeric_cast<int>(outputDim) || axis > boost::numeric_cast<int>(tensorShape.GetNumDimensions()))
    {
        throw InvalidArgumentException(
            boost::str(boost::format("Invalid expansion axis %1% for %2%D input tensor. %3%") %
                       axis %
                       tensorShape.GetNumDimensions() %
                       CHECK_LOCATION().AsString()));
    }

    if (axis < 0)
    {
        axis = boost::numeric_cast<int>(outputDim) + axis;
    }

    std::vector<unsigned int> outputShape;
    for (unsigned int i = 0; i < tensorShape.GetNumDimensions(); ++i)
    {
        outputShape.push_back(tensorShape[i]);
    }
    outputShape.insert(outputShape.begin() + axis, 1);

    return TensorShape(outputDim, outputShape.data());
}

FindMinMax()

std::pair< float, float > FindMinMax

(

armnn::ITensorHandle *

tensorHandle

)

Definition at line 58 of file TensorUtils.cpp.

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

Referenced by NetworkQuantizer::Refine().

{
    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 140 of file TensorUtils.cpp.

References ARMNN_ASSERT, and TensorShape::GetNumDimensions().

Referenced by GetPerAxisParams().

{
    unsigned int numDim = shape.GetNumDimensions();
    ARMNN_ASSERT(axis <= numDim - 1);
    unsigned int count = 1;
    for (unsigned int i = axis; 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 113 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 152 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()

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.

Referenced by CaffeParserBase::AddConvLayerWithDepthwiseConv(), CaffeParserBase::AddConvLayerWithSplits(), DepthwiseConvolution2dAsymmetricTestImpl(), DepthwiseConvolution2dDepthMul1TestImpl(), DepthwiseConvolution2dTestImpl(), CaffeParserBase::ParseBatchNormLayer(), CaffeParserBase::ParseConcatLayer(), CaffeParserBase::ParseConvLayer(), CaffeParserBase::ParseEltwiseLayer(), CaffeParserBase::ParseInnerProductLayer(), CaffeParserBase::ParseLRNLayer(), CaffeParserBase::ParsePoolingLayer(), CaffeParserBase::ParseReluLayer(), CaffeParserBase::ParseScaleLayer(), CaffeParserBase::ParseSoftmaxLayer(), and SimpleConvolution2dTestImpl().

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

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 127 of file TensorUtils.cpp.

References ARMNN_ASSERT_MSG, and armnn::numeric_cast().

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

{
    ARMNN_ASSERT_MSG(axis < boost::numeric_cast<int>(inputDimension),
                     "Required axis index greater than number of dimensions.");
    ARMNN_ASSERT_MSG(axis >= -boost::numeric_cast<int>(inputDimension),
                     "Required axis index lower than negative of the number of dimensions");

    unsigned int uAxis = axis < 0  ?
                         inputDimension - boost::numeric_cast<unsigned int>(abs(axis))
                         : boost::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.

Referenced by InferenceModel< IParser, TDataType >::GetAllQuantizationParams(), and main().

{
    armnn::InputTensors inputTensors;

    const size_t numInputs = inputBindings.size();
    if (numInputs != inputDataContainers.size())
    {
        throw armnn::Exception(boost::str(boost::format("The number of inputs does not match number of "
                                                        "tensor data containers: %1% != %2%")
                                          % numInputs
                                          % inputDataContainers.size()));
    }

    for (size_t i = 0; i < numInputs; i++)
    {
        const armnn::BindingPointInfo& inputBinding = inputBindings[i];
        const TContainer& inputData = inputDataContainers[i];

        boost::apply_visitor([&](auto&& value)
        {
            if (value.size() != inputBinding.second.GetNumElements())
            {
               throw armnn::Exception(boost::str(boost::format("The input tensor has incorrect size "
                                                               "(expected %1% got %2%)")
                                                 % inputBinding.second.GetNumElements()
                                                 % value.size()));
            }

            armnn::ConstTensor inputTensor(inputBinding.second, 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.

Referenced by InferenceModel< IParser, TDataType >::GetAllQuantizationParams(), and main().

{
    armnn::OutputTensors outputTensors;

    const size_t numOutputs = outputBindings.size();
    if (numOutputs != outputDataContainers.size())
    {
        throw armnn::Exception(boost::str(boost::format("Number of outputs does not match number of "
                                                        "tensor data containers: %1% != %2%")
                                          % numOutputs
                                          % outputDataContainers.size()));
    }

    for (size_t i = 0; i < numOutputs; i++)
    {
        const armnn::BindingPointInfo& outputBinding = outputBindings[i];
        TContainer& outputData = outputDataContainers[i];

        boost::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 36 of file VerificationHelpers.cpp.

References CheckLocation::AsString().

{
    if (value < 0)
    {
        throw ParseException(
            boost::str(
                boost::format("'%1%' must be non-negative, received: %2% at %3%") %
                              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 34 of file DataLayoutIndexed.cpp.

References DataLayoutIndexed::GetDataLayout().

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

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

operator==() [2/2]

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

Definition at line 39 of file DataLayoutIndexed.cpp.

References DataLayoutIndexed::GetDataLayout().

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

ParseLine()

CsvRow armnnUtils::ParseLine

(

const std::string &

csvLine

)

Definition at line 20 of file CsvReader.cpp.

References armnn::stringUtils::StringTrimCopy(), and CsvRow::values.

Referenced by CsvReader::ParseFile(), and CsvReader::ParseVector().

{
    Tokenizer tokenizer(csvLine);
    CsvRow entry;

    for (const auto &token : tokenizer)
    {
        entry.values.push_back(armnn::stringUtils::StringTrimCopy(token));
    }
    return entry;
}

Permute()

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

Definition at line 121 of file Permute.cpp.

Referenced by BOOST_AUTO_TEST_CASE(), armnnTfParser::ConvertTfTensorDataType(), armnn::DepthToSpace(), DepthwiseConvolution2dAsymmetricTestImpl(), DepthwiseConvolution2dDepthMul1TestImpl(), DepthwiseConvolution2dTestImpl(), PermuteLayer::PermuteLayer(), PermuteTensorNchwToNhwc(), PermuteTensorNhwcToNchw(), PrepareImageTensor< float >(), and SimpleConvolution2dTestImpl().

{
    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 armnnTfParser::ConvertTfTensorDataType(), armnn::ConvertWeightTensorInfoFromArmnnToAcl(), PermuteLayer::InferOutputShapes(), Permuted(), PermuteInputsForConcat(), armnn::PermuteTensor(), PermuteTensorData(), PermuteTensorNchwToNhwc(), PermuteTensorNhwcToNchw(), and MovePermuteUpImpl::Run().

{
    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 114 of file Permute.cpp.

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

{
    armnn::TensorInfo outInfo(info);
    outInfo.SetShape(Permuted(info.GetShape(), mappings));
    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 TfLiteParser::OutputShapeOfReshape().

{
    const uint32_t inputRank = concatDescriptor.GetNumDimensions();

    // double check dimensions of the tensors
    if (inputTensorInfo.GetNumDimensions() != inputRank)
    {
        throw armnn::ParseException(
            boost::str(
                boost::format(
                    "The number of dimensions: %1% for input tensors of the "
                    "concatenation op should be %2% %3%")
                % 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 106 of file QuantizeHelper.hpp.

{
    std::vector<T> quantized;
    quantized.reserve(boost::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 122 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 128 of file QuantizeHelper.hpp.

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

SelectiveDequantize()

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

Definition at line 92 of file QuantizeHelper.hpp.

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

Referenced by ApplyBias().

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

SelectiveQuantize()

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

Definition at line 86 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 41 of file ModelAccuracyChecker.cpp.

Referenced by LoadModelOutputLabels(), and main().

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

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.

References ARMNN_ASSERT.

Referenced by LoadModelOutputLabels().

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

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 BOOST_AUTO_TEST_CASE(), and 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 TransposeLayer::InferOutputShapes(), armnnTfParser::OutputShapeOfExpandDims(), 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 55 of file VerificationHelpers.cpp.

References CheckLocation::AsString().

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

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.

Referenced by PrepareImageTensor< float >().