Holds all parameters necessary to execute a network Check ExecuteNetworkProgramOptions.cpp for a description of each parameter. More...

#include <ExecuteNetworkParams.hpp>

Public Types
enum	TfLiteExecutor { ArmNNTfLiteParser, ArmNNTfLiteDelegate, TfliteInterpreter }

using	TensorShapePtr = std::unique_ptr< armnn::TensorShape >

Public Member Functions
void	ValidateParams ()

Public Attributes
std::string	m_CachedNetworkFilePath

std::vector< armnn::BackendId >	m_ComputeDevices

bool	m_Concurrent

bool	m_DequantizeOutput

std::string	m_DynamicBackendsPath

bool	m_EnableBf16TurboMode

bool	m_EnableFastMath = false

bool	m_EnableFp16TurboMode

bool	m_EnableLayerDetails = false

bool	m_EnableProfiling

bool	m_GenerateTensorData

bool	m_InferOutputShape = false

bool	m_EnableDelegate = false

std::vector< std::string >	m_InputNames

std::vector< std::string >	m_InputTensorDataFilePaths

std::vector< TensorShapePtr >	m_InputTensorShapes

std::vector< std::string >	m_InputTypes

bool	m_IsModelBinary

size_t	m_Iterations

std::string	m_ModelFormat

std::string	m_ModelPath

unsigned int	m_NumberOfThreads

bool	m_OutputDetailsToStdOut

bool	m_OutputDetailsOnlyToStdOut

std::vector< std::string >	m_OutputNames

std::vector< std::string >	m_OutputTensorFiles

std::vector< std::string >	m_OutputTypes

bool	m_ParseUnsupported = false

bool	m_PrintIntermediate

bool	m_DontPrintOutputs

bool	m_QuantizeInput

bool	m_SaveCachedNetwork

size_t	m_SimultaneousIterations

size_t	m_SubgraphId

double	m_ThresholdTime

int	m_TuningLevel

std::string	m_TuningPath

std::string	m_MLGOTuningFilePath

TfLiteExecutor	m_TfLiteExecutor

size_t	m_ThreadPoolSize

Detailed Description

Holds all parameters necessary to execute a network Check ExecuteNetworkProgramOptions.cpp for a description of each parameter.

Definition at line 17 of file ExecuteNetworkParams.hpp.

Member Typedef Documentation

◆ TensorShapePtr

using TensorShapePtr = std::unique_ptr<armnn::TensorShape>

Definition at line 19 of file ExecuteNetworkParams.hpp.

Member Enumeration Documentation

◆ TfLiteExecutor

enum TfLiteExecutor

strong

Enumerator
ArmNNTfLiteParser
ArmNNTfLiteDelegate
TfliteInterpreter

Definition at line 21 of file ExecuteNetworkParams.hpp.

     {
         ArmNNTfLiteParser,
         ArmNNTfLiteDelegate,
         TfliteInterpreter
     };

Member Function Documentation

◆ ValidateParams()

void ValidateParams ( )

Definition at line 111 of file ExecuteNetworkParams.cpp.

References ARMNN_LOG, CheckClTuningParameter(), CheckModelFormat(), armnn::DetailsWithEvents, armnn::InferAndValidate, IsModelBinary(), m_CachedNetworkFilePath, m_ComputeDevices, OptimizerOptions::m_Debug, m_DynamicBackendsPath, m_EnableBf16TurboMode, m_EnableFastMath, m_EnableFp16TurboMode, m_EnableLayerDetails, m_EnableProfiling, m_GenerateTensorData, m_InferOutputShape, m_InputNames, m_InputTensorDataFilePaths, m_InputTensorShapes, m_InputTypes, m_IsModelBinary, m_Iterations, m_MLGOTuningFilePath, m_ModelFormat, OptimizerOptions::m_ModelOptions, m_ModelPath, m_NumberOfThreads, m_OutputNames, m_OutputTensorFiles, m_OutputTypes, m_PrintIntermediate, OptimizerOptions::m_ProfilingEnabled, OptimizerOptions::m_ReduceFp32ToBf16, OptimizerOptions::m_ReduceFp32ToFp16, m_SaveCachedNetwork, OptimizerOptions::m_shapeInferenceMethod, m_ThresholdTime, m_TuningLevel, m_TuningPath, DelegateOptions::SetDynamicBackendsPath(), DelegateOptions::SetGpuProfilingState(), DelegateOptions::SetInternalProfilingParams(), DelegateOptions::SetOptimizerOptions(), DelegateOptions::SetSerializeToDot(), armnn::ValidateOnly, and ValidatePaths().

Referenced by ProgramOptions::ValidateExecuteNetworkParams().

 {
     if (m_DynamicBackendsPath == "")
     {
         // Check compute devices are valid unless they are dynamically loaded at runtime
         std::string invalidBackends;
         if (!CheckRequestedBackendsAreValid(m_ComputeDevices, armnn::Optional<std::string&>(invalidBackends)))
         {
             ARMNN_LOG(fatal) << "The list of preferred devices contains invalid backend IDs: "
                              << invalidBackends;
         }
     }
 
     CheckClTuningParameter(m_TuningLevel, m_TuningPath, m_ComputeDevices);
 
     if (m_EnableBf16TurboMode && m_EnableFp16TurboMode)
     {
         throw armnn::InvalidArgumentException("BFloat16 and Float16 turbo mode cannot be "
                                               "enabled at the same time.");
     }
 
     m_IsModelBinary = IsModelBinary(m_ModelFormat);
 
     CheckModelFormat(m_ModelFormat);
 
     // Check input tensor shapes
     if ((m_InputTensorShapes.size() != 0) &&
         (m_InputTensorShapes.size() != m_InputNames.size()))
     {
         throw armnn::InvalidArgumentException("input-name and input-tensor-shape must have "
                                               "the same amount of elements. ");
     }
 
     if (m_InputTensorDataFilePaths.size() != 0)
     {
         if (!ValidatePaths(m_InputTensorDataFilePaths, true))
         {
             throw armnn::InvalidArgumentException("One or more input data file paths are not valid.");
         }
 
         if (m_InputTensorDataFilePaths.size() < m_InputNames.size())
         {
             throw armnn::InvalidArgumentException(
                     fmt::format("According to the number of input names the user provided the network has {} "
                                 "inputs. But only {} input-tensor-data file paths were provided. Each input of the "
                                 "model is expected to be stored in it's own file.",
                                 m_InputNames.size(),
                                 m_InputTensorDataFilePaths.size()));
         }
         else if (m_InputTensorDataFilePaths.size() % m_InputNames.size() != 0)
         {
             throw armnn::InvalidArgumentException(
                     fmt::format("According to the number of input names the user provided the network has {} "
                                 "inputs. The user specified {} input-tensor-data file paths which is not "
                                 "divisible by the number of inputs.",
                                 m_InputNames.size(),
                                 m_InputTensorDataFilePaths.size()));
         }
     }
 
     if (m_InputTypes.size() == 0)
     {
         //Defaults the value of all inputs to "float"
         m_InputTypes.assign(m_InputNames.size(), "float");
     }
     else if ((m_InputTypes.size() != 0) &&
              (m_InputTypes.size() != m_InputNames.size()))
     {
         throw armnn::InvalidArgumentException("input-name and input-type must have the same amount of elements.");
     }
 
     // Make sure that the number of input files given is divisible by the number of inputs of the model
     if (!(m_InputTensorDataFilePaths.size() % m_InputNames.size() == 0))
     {
         throw armnn::InvalidArgumentException(
                 fmt::format("The number of input-tensor-data files ({0}) is not divisible by the "
                             "number of inputs ({1} according to the number of input names).",
                             m_InputTensorDataFilePaths.size(),
                             m_InputNames.size()));
     }
 
     if (m_OutputTypes.size() == 0)
     {
         //Defaults the value of all outputs to "float"
         m_OutputTypes.assign(m_OutputNames.size(), "float");
     }
     else if ((m_OutputTypes.size() != 0) &&
              (m_OutputTypes.size() != m_OutputNames.size()))
     {
         throw armnn::InvalidArgumentException("output-name and output-type must have the same amount of elements.");
     }
 
     // Make sure that the number of output files given is equal to the number of outputs of the model
     // or equal to the number of outputs of the model multiplied with the number of iterations
     if (!m_OutputTensorFiles.empty())
     {
         if ((m_OutputTensorFiles.size() != m_OutputNames.size()) &&
             (m_OutputTensorFiles.size() != m_OutputNames.size() * m_Iterations))
         {
             std::stringstream errmsg;
             auto numOutputs = m_OutputNames.size();
             throw armnn::InvalidArgumentException(
                     fmt::format("The user provided {0} output-tensor files. The only allowed number of output-tensor "
                                 "files is the number of outputs of the network ({1} according to the number of "
                                 "output names) or the number of outputs multiplied with the number of times the "
                                 "network should be executed (NumOutputs * NumIterations = {1} * {2} = {3}).",
                                 m_OutputTensorFiles.size(),
                                 numOutputs,
                                 m_Iterations,
                                 numOutputs*m_Iterations));
         }
     }
 
     // Check that threshold time is not less than zero
     if (m_ThresholdTime < 0)
     {
         throw armnn::InvalidArgumentException("Threshold time supplied as a command line argument is less than zero.");
     }
 
     // Warn if ExecuteNetwork will generate dummy input data
     if (m_GenerateTensorData)
     {
         ARMNN_LOG(warning) << "No input files provided, input tensors will be filled with 0s.";
     }
 }