NetworkExecutionUtils.hpp File Reference

#include <armnn/Logging.hpp>
#include <armnn/utility/StringUtils.hpp>
#include <armnn/utility/NumericCast.hpp>
#include <armnn/BackendRegistry.hpp>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <iterator>

Go to the source code of this file.

Classes
struct	OutputWriteInfo

Functions
bool	CheckInferenceTimeThreshold (const std::chrono::duration< double, std::milli > &duration, const double &thresholdTime)
	Given a measured duration and a threshold time tell the user whether we succeeded or not. More...
bool	CheckRequestedBackendsAreValid (const std::vector< armnn::BackendId > &backendIds, armnn::Optional< std::string &> invalidBackendIds=armnn::EmptyOptional())
std::vector< unsigned int >	ParseArray (std::istream &stream)
std::vector< std::string >	ParseStringList (const std::string &inputString, const char *delimiter)
	Splits a given string at every accurance of delimiter into a vector of string. More...
template<typename T >
std::vector< float >	DequantizeArray (const void *array, unsigned int numElements, float scale, int32_t offset)
	Dequantize an array of a given type. More...
void	LogAndThrow (std::string eMsg)
bool	ValidatePath (const std::string &file, const bool expectFile)
	Verifies if the given string is a valid path. More...
bool	ValidatePaths (const std::vector< std::string > &fileVec, const bool expectFile)
	Verifies if a given vector of strings are valid paths. More...
template<typename Integer , typename std::enable_if_t< std::is_integral< Integer >::value > * = nullptr>
std::function< Integer(const std::string &)>	GetParseElementFunc ()
	Returns a function of read the given type as a string. More...
template<typename Float , std::enable_if_t< std::is_floating_point< Float >::value > * = nullptr>
std::function< Float(const std::string &)>	GetParseElementFunc ()
template<typename T >
void	PopulateTensorWithData (T *tensor, const unsigned int numElements, const armnn::Optional< std::string > &dataFile, const std::string &inputName)
template<typename T >
void	WriteToFile (const std::string &outputTensorFileName, const std::string &outputName, const T *const array, const unsigned int numElements)
template<typename T >
void	PrintTensor (OutputWriteInfo &info, const char *formatString)
template<typename T >
void	PrintQuantizedTensor (OutputWriteInfo &info)
template<typename T , typename TParseElementFunc >
std::vector< T >	ParseArrayImpl (std::istream &stream, TParseElementFunc parseElementFunc, const char *chars="\,:")
template<typename T >
float	ComputeRMSE (const void *expected, const void *actual, const size_t size)
	Compute the root-mean-square error (RMSE) More...

Function Documentation

CheckInferenceTimeThreshold()

bool CheckInferenceTimeThreshold	(	const std::chrono::duration< double, std::milli > &	duration,
		const double &	thresholdTime
	)

Given a measured duration and a threshold time tell the user whether we succeeded or not.

Parameters

duration	the measured inference duration.
thresholdTime	the threshold time in milliseconds.

Returns

false if the measured time exceeded the threshold.

Definition at line 17 of file NetworkExecutionUtils.cpp.

References ARMNN_LOG.

Referenced by ArmNNExecutor::ArmNNExecutor(), and TfLiteExecutor::Execute().

{
    ARMNN_LOG(info) << "Inference time: " << std::setprecision(2)
                    << std::fixed << duration.count() << " ms\n";
    // If thresholdTime == 0.0 (default), then it hasn't been supplied at command line
    if (thresholdTime != 0.0)
    {
        ARMNN_LOG(info) << "Threshold time: " << std::setprecision(2)
                        << std::fixed << thresholdTime << " ms";
        auto thresholdMinusInference = thresholdTime - duration.count();
        ARMNN_LOG(info) << "Threshold time - Inference time: " << std::setprecision(2)
                        << std::fixed << thresholdMinusInference << " ms" << "\n";
        if (thresholdMinusInference < 0)
        {
            std::string errorMessage = "Elapsed inference time is greater than provided threshold time.";
            ARMNN_LOG(fatal) << errorMessage;
            return false;
        }
    }
    return true;
}

CheckRequestedBackendsAreValid()

bool CheckRequestedBackendsAreValid ( const std::vector< armnn::BackendId > &  backendIds, armnn::Optional< std::string &>  invalidBackendIds = armnn::EmptyOptional()  )

inline

Definition at line 28 of file NetworkExecutionUtils.hpp.

References armnn::BackendRegistryInstance(), BackendRegistry::GetBackendIds(), ParseArray(), and ParseStringList().

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

{
    if (backendIds.empty())
    {
        return false;
    }

    armnn::BackendIdSet validBackendIds = armnn::BackendRegistryInstance().GetBackendIds();

    bool allValid = true;
    for (const auto& backendId : backendIds)
    {
        if (std::find(validBackendIds.begin(), validBackendIds.end(), backendId) == validBackendIds.end())
        {
            allValid = false;
            if (invalidBackendIds)
            {
                if (!invalidBackendIds.value().empty())
                {
                    invalidBackendIds.value() += ", ";
                }
                invalidBackendIds.value() += backendId;
            }
        }
    }
    return allValid;
}

ComputeRMSE()

float ComputeRMSE	(	const void *	expected,
		const void *	actual,
		const size_t	size
	)

Compute the root-mean-square error (RMSE)

Parameters

expected
actual
size	size of the tensor

Returns

float the RMSE

Definition at line 278 of file NetworkExecutionUtils.hpp.

{
    auto typedExpected = reinterpret_cast<const T*>(expected);
    auto typedActual = reinterpret_cast<const T*>(actual);

    T errorSum = 0;

    for (unsigned int i = 0; i < size; i++)
    {
        if (std::abs(typedExpected[i] - typedActual[i]) != 0)
        {
            std::cout << "";
        }
        errorSum += std::pow(std::abs(typedExpected[i] - typedActual[i]), 2);
    }

    float rmse = std::sqrt(armnn::numeric_cast<float>(errorSum) / armnn::numeric_cast<float>(size / sizeof(T)));
    return rmse;
}

DequantizeArray()

std::vector<float> DequantizeArray	(	const void *	array,
		unsigned int	numElements,
		float	scale,
		int32_t	offset
	)

Dequantize an array of a given type.

Parameters

array	Type erased array to dequantize
numElements	Elements in the array
array	Type erased array to dequantize

Definition at line 67 of file NetworkExecutionUtils.hpp.

References armnn::Dequantize(), LogAndThrow(), ValidatePath(), and ValidatePaths().

{
    const T* quantizedArray = reinterpret_cast<const T*>(array);
    std::vector<float> dequantizedVector;
    dequantizedVector.reserve(numElements);
    for (unsigned int i = 0; i < numElements; ++i)
    {
        float f = armnn::Dequantize(*(quantizedArray + i), scale, offset);
        dequantizedVector.push_back(f);
    }
    return dequantizedVector;
}

GetParseElementFunc() [1/2]

std::function<Integer(const std::string&)> GetParseElementFunc

(

)

Returns a function of read the given type as a string.

Definition at line 100 of file NetworkExecutionUtils.hpp.

References armnn::numeric_cast().

{
    return [](const std::string& s) { return armnn::numeric_cast<Integer>(std::stoi(s)); };
}

GetParseElementFunc() [2/2]

std::function<Float(const std::string&)> GetParseElementFunc

(

)

Definition at line 106 of file NetworkExecutionUtils.hpp.

{
    return [](const std::string& s) { return std::stof(s); };
}

LogAndThrow()

void LogAndThrow

(

std::string

eMsg

)

Definition at line 75 of file NetworkExecutionUtils.cpp.

References ARMNN_LOG.

Referenced by ArmNNExecutor::CompareAndPrintResult(), DequantizeArray(), TfLiteExecutor::Execute(), ArmNNExecutor::PrintNetworkInfo(), and TfLiteExecutor::TfLiteExecutor().

{
    ARMNN_LOG(error) << eMsg;
    throw armnn::Exception(eMsg);
}

ParseArray()

std::vector<unsigned int> ParseArray

(

std::istream &

stream

)

Definition at line 55 of file NetworkExecutionUtils.cpp.

References armnn::numeric_cast().

Referenced by CheckRequestedBackendsAreValid(), and ProgramOptions::ParseOptions().

{
    return ParseArrayImpl<unsigned int>(
            stream,
            [](const std::string& s) { return armnn::numeric_cast<unsigned int>(std::stoi(s)); });
}

ParseArrayImpl()

std::vector<T> ParseArrayImpl	(	std::istream &	stream,
		TParseElementFunc	parseElementFunc,
		const char *	chars = "\t ,:"
	)

Definition at line 245 of file NetworkExecutionUtils.hpp.

References ARMNN_LOG, and armnn::stringUtils::StringTokenizer().

                                                                                                             :")
{
    std::vector<T> result;
    // Processes line-by-line.
    std::string line;
    while (std::getline(stream, line))
    {
        std::vector<std::string> tokens = armnn::stringUtils::StringTokenizer(line, chars);
        for (const std::string& token : tokens)
        {
            if (!token.empty()) // See https://stackoverflow.com/questions/10437406/
            {
                try
                {
                    result.push_back(parseElementFunc(token));
                }
                catch (const std::exception&)
                {
                    ARMNN_LOG(error) << "'" << token << "' is not a valid number. It has been ignored.";
                }
            }
        }
    }

    return result;
}

ParseStringList()

std::vector<std::string> ParseStringList	(	const std::string &	inputString,
		const char *	delimiter
	)

Splits a given string at every accurance of delimiter into a vector of string.

Definition at line 10 of file NetworkExecutionUtils.cpp.

References armnn::stringUtils::StringTrimCopy().

Referenced by CheckRequestedBackendsAreValid(), GetBackendIDs(), and ProgramOptions::ParseOptions().

{
    std::stringstream stream(inputString);
    return ParseArrayImpl<std::string>(stream, [](const std::string& s) {
        return armnn::stringUtils::StringTrimCopy(s); }, delimiter);
}

PopulateTensorWithData()

void PopulateTensorWithData	(	T *	tensor,
		const unsigned int	numElements,
		const armnn::Optional< std::string > &	dataFile,
		const std::string &	inputName
	)

Definition at line 112 of file NetworkExecutionUtils.hpp.

References ARMNN_LOG, OptionalBase::has_value(), armnn::stringUtils::StringTokenizer(), and OptionalReferenceSwitch< IsReference, T >::value().

{
    const bool readFromFile = dataFile.has_value() && !dataFile.value().empty();

    std::ifstream inputTensorFile;
    if (!readFromFile)
    {
        std::fill(tensor, tensor + numElements, 0);
        return;
    }
    else
    {
        inputTensorFile = std::ifstream(dataFile.value());
    }

    auto parseElementFunc = GetParseElementFunc<T>();
    std::string line;
    unsigned int index = 0;
    while (std::getline(inputTensorFile, line))
    {
        std::vector<std::string> tokens = armnn::stringUtils::StringTokenizer(line, "\t ,:");
        for (const std::string& token : tokens)
        {
            if (!token.empty()) // See https://stackoverflow.com/questions/10437406/
            {
                try
                {
                    if (index == numElements)
                    {
                        ARMNN_LOG(error) << "Number of elements: " << (index +1) << " in file \"" << dataFile.value()
                                         << "\" does not match number of elements: " << numElements
                                         << " for input \"" << inputName << "\".";
                    }
                    *(tensor + index) = parseElementFunc(token);
                    index++;
                }
                catch (const std::exception&)
                {
                    ARMNN_LOG(error) << "'" << token << "' is not a valid number. It has been ignored.";
                }
            }
        }
    }

    if (index != numElements)
    {
        ARMNN_LOG(error) << "Number of elements: " << (index +1) << " in file \"" << inputName
                         << "\" does not match number of elements: " << numElements
                         << " for input \"" << inputName << "\".";
    }
}

PrintQuantizedTensor()

void PrintQuantizedTensor

(

OutputWriteInfo &

info

)

Definition at line 218 of file NetworkExecutionUtils.hpp.

References OptionalBase::has_value(), OutputWriteInfo::m_OutputName, OutputWriteInfo::m_OutputTensorFile, OutputWriteInfo::m_PrintTensor, OutputWriteInfo::m_Tensor, OptionalReferenceSwitch< IsReference, T >::value(), and WriteToFile().

{
    std::vector<float> dequantizedValues;
    auto tensor = info.m_Tensor;
    dequantizedValues = DequantizeArray<T>(tensor.GetMemoryArea(),
                                           tensor.GetNumElements(),
                                           tensor.GetInfo().GetQuantizationScale(),
                                           tensor.GetInfo().GetQuantizationOffset());

    if (info.m_OutputTensorFile.has_value())
    {
        WriteToFile(info.m_OutputTensorFile.value(),
                    info.m_OutputName,
                    dequantizedValues.data(),
                    tensor.GetNumElements());
    }

    if (info.m_PrintTensor)
    {
        std::for_each(dequantizedValues.begin(), dequantizedValues.end(), [&](float value)
        {
            printf("%f ", value);
        });
    }
}

PrintTensor()

void PrintTensor	(	OutputWriteInfo &	info,
		const char *	formatString
	)

Definition at line 196 of file NetworkExecutionUtils.hpp.

References BaseTensor< MemoryType >::GetMemoryArea(), BaseTensor< MemoryType >::GetNumElements(), OptionalBase::has_value(), OutputWriteInfo::m_OutputName, OutputWriteInfo::m_OutputTensorFile, OutputWriteInfo::m_PrintTensor, OutputWriteInfo::m_Tensor, OptionalReferenceSwitch< IsReference, T >::value(), and WriteToFile().

{
    const T* array = reinterpret_cast<const T*>(info.m_Tensor.GetMemoryArea());

    if (info.m_OutputTensorFile.has_value())
    {
        WriteToFile(info.m_OutputTensorFile.value(),
                    info.m_OutputName,
                    array,
                    info.m_Tensor.GetNumElements());
    }

    if (info.m_PrintTensor)
    {
        for (unsigned int i = 0; i < info.m_Tensor.GetNumElements(); i++)
        {
            printf(formatString, array[i]);
        }
    }
}

ValidatePath()

bool ValidatePath	(	const std::string &	file,
		const bool	expectFile
	)

Verifies if the given string is a valid path.

Reports invalid paths to std::err.

Parameters

file	string - A string containing the path to check
expectFile	bool - If true, checks for a regular file.

Returns

bool - True if given string is a valid path., false otherwise.

Definition at line 40 of file NetworkExecutionUtils.cpp.

Referenced by CheckClTuningParameter(), DequantizeArray(), and ValidatePaths().

{
    if (!fs::exists(file))
    {
        std::cerr << "Given file path '" << file << "' does not exist" << std::endl;
        return false;
    }
    if (!fs::is_regular_file(file) && expectFile)
    {
        std::cerr << "Given file path '" << file << "' is not a regular file" << std::endl;
        return false;
    }
    return true;
}

ValidatePaths()

bool ValidatePaths	(	const std::vector< std::string > &	fileVec,
		const bool	expectFile
	)

Verifies if a given vector of strings are valid paths.

Reports invalid paths to std::err.

Parameters

fileVec	vector of string - A vector of string containing the paths to check
expectFile	bool - If true, checks for a regular file.

Returns

bool - True if all given strings are valid paths., false otherwise.

Definition at line 62 of file NetworkExecutionUtils.cpp.

References ValidatePath().

Referenced by DequantizeArray(), and ExecuteNetworkParams::ValidateParams().

{
    bool allPathsValid = true;
    for (auto const& file : fileVec)
    {
        if(!ValidatePath(file, expectFile))
        {
            allPathsValid = false;
        }
    }
    return allPathsValid;
}

WriteToFile()

void WriteToFile	(	const std::string &	outputTensorFileName,
		const std::string &	outputName,
		const T *const	array,
		const unsigned int	numElements
	)

Definition at line 168 of file NetworkExecutionUtils.hpp.

References ARMNN_LOG.

Referenced by PrintQuantizedTensor(), and PrintTensor().

{
    std::ofstream outputTensorFile;
    outputTensorFile.open(outputTensorFileName, std::ofstream::out | std::ofstream::trunc);
    if (outputTensorFile.is_open())
    {
        outputTensorFile << outputName << ": ";
        std::copy(array, array + numElements, std::ostream_iterator<T>(outputTensorFile, " "));
    }
    else
    {
        ARMNN_LOG(info) << "Output Tensor File: " << outputTensorFileName << " could not be opened!";
    }
    outputTensorFile.close();
}