armnnUtils Namespace Reference

Namespaces
	Filesystem
	Processes
	Sockets

Classes
class	CsvReader
struct	CsvRow
class	DataLayoutIndexed
class	FloatingPointConverter
struct	IsFloatingPointIterator
class	ModelAccuracyChecker
struct	ParserPrototxtFixture
struct	SelectiveQuantizer
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)
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)
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)
std::string	Strip (const std::string &originalString, const std::string &characterSet)
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...
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 18 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;
}

ExpandDims()

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

Definition at line 85 of file TensorUtils.cpp.

References CHECK_LOCATION, and TensorShape::GetNumDimensions().

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 TensorShape::GetNumDimensions().

Referenced by GetPerAxisParams().

{
    unsigned int numDim = shape.GetNumDimensions();
    BOOST_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 TensorShape::GetNumDimensions().

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

{
    BOOST_ASSERT(firstAxisInclusive <= lastAxisExclusive);
    BOOST_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.

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

{
    BOOST_ASSERT_MSG(axis < boost::numeric_cast<int>(inputDimension),
                     "Required axis index greater than number of dimensions.");
    BOOST_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 111 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(), main(), and InferenceModel< IParser, TDataType >::Run().

{
    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(), main(), and InferenceModel< IParser, TDataType >::Run().

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

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 CsvRow::values.

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

{
    Tokenizer tokenizer(csvLine);
    CsvRow entry;

    for (const auto &token : tokenizer)
    {
        entry.values.push_back(boost::trim_copy(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 89 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 105 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 111 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 75 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 69 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.

Referenced by LoadModelOutputLabels().

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

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