12 #if defined(ARMNN_SERIALIZER) 15 #if defined(ARMNN_CAFFE_PARSER) 18 #if defined(ARMNN_TF_PARSER) 21 #if defined(ARMNN_TF_LITE_PARSER) 24 #if defined(ARMNN_ONNX_PARSER) 28 template<armnn::DataType NonQuantizedType>
31 template<armnn::DataType QuantizedType>
33 const float& quantizationScale,
34 const int32_t& quantizationOffset);
37 auto ParseDataArray<armnn::DataType::Float32>(std::istream& stream)
39 return ParseArrayImpl<float>(stream, [](
const std::string& s) {
return std::stof(s); });
43 auto ParseDataArray<armnn::DataType::Signed32>(std::istream& stream)
45 return ParseArrayImpl<int>(stream, [](
const std::string& s) {
return std::stoi(s); });
49 auto ParseDataArray<armnn::DataType::QAsymmU8>(std::istream& stream)
51 return ParseArrayImpl<uint8_t>(stream,
56 auto ParseDataArray<armnn::DataType::QAsymmU8>(std::istream& stream,
57 const float& quantizationScale,
58 const int32_t& quantizationOffset)
60 return ParseArrayImpl<uint8_t>(stream,
61 [&quantizationScale, &quantizationOffset](
const std::string& s)
64 armnn::Quantize<uint8_t>(std::stof(s),
70 template<armnn::DataType ArmnnType,
typename T = armnn::ResolveType<ArmnnType>>
73 return std::vector<T>(numElements,
static_cast<T
>(0));
77 std::vector<unsigned int>
ParseArray(std::istream& stream)
79 return ParseArrayImpl<unsigned int>(
84 std::vector<std::string>
ParseStringList(
const std::string& inputString,
const char* delimiter)
86 std::stringstream stream(inputString);
87 return ParseArrayImpl<std::string>(stream, [](
const std::string& s) {
94 const std::string& outputTensorFile,
95 bool dequantizeOutput)
96 : m_OutputBinding(binding)
97 , m_Scale(info.GetQuantizationScale())
98 , m_Offset(info.GetQuantizationOffset())
99 , m_OutputTensorFile(outputTensorFile)
100 , m_DequantizeOutput(dequantizeOutput) {}
104 ForEachValue(values, [](
float value)
106 printf(
"%f ", value);
113 if(m_DequantizeOutput)
115 auto& scale = m_Scale;
116 auto& offset = m_Offset;
117 std::vector<float> dequantizedValues;
118 ForEachValue(values, [&scale, &offset, &dequantizedValues](uint8_t value)
121 printf(
"%f ", dequantizedValue);
122 dequantizedValues.push_back(dequantizedValue);
124 WriteToFile(dequantizedValues);
128 const std::vector<int> intValues(values.begin(), values.end());
135 ForEachValue(values, [](
int value)
137 printf(
"%d ", value);
142 template<
typename Container,
typename Delegate>
143 void TensorPrinter::ForEachValue(
const Container& c, Delegate delegate)
145 std::cout << m_OutputBinding <<
": ";
146 for (
const auto& value : c)
154 void TensorPrinter::WriteToFile(
const std::vector<T>& values)
156 if (!m_OutputTensorFile.empty())
158 std::ofstream outputTensorFile;
159 outputTensorFile.open(m_OutputTensorFile, std::ofstream::out | std::ofstream::trunc);
160 if (outputTensorFile.is_open())
162 outputTensorFile << m_OutputBinding <<
": ";
163 std::copy(values.begin(), values.end(), std::ostream_iterator<T>(outputTensorFile,
" "));
167 ARMNN_LOG(info) <<
"Output Tensor File: " << m_OutputTensorFile <<
" could not be opened!";
169 outputTensorFile.close();
173 using TContainer = mapbox::util::variant<std::vector<float>, std::vector<int>, std::vector<unsigned char>>;
177 unsigned int numElements,
178 const std::string& dataTypeStr,
182 const bool readFromFile = dataFile.
has_value() && !dataFile.
value().empty();
183 const bool quantizeData = qParams.
has_value();
185 std::ifstream inputTensorFile;
188 inputTensorFile = std::ifstream(dataFile.
value());
191 if (dataTypeStr.compare(
"float") == 0)
195 const float qScale = qParams.
value().first;
196 const int qOffset = qParams.
value().second;
198 tensorData = readFromFile ?
199 ParseDataArray<armnn::DataType::QAsymmU8>(inputTensorFile, qScale, qOffset) :
200 GenerateDummyTensorData<armnn::DataType::QAsymmU8>(numElements);
204 tensorData = readFromFile ?
205 ParseDataArray<armnn::DataType::Float32>(inputTensorFile) :
206 GenerateDummyTensorData<armnn::DataType::Float32>(numElements);
209 else if (dataTypeStr.compare(
"int") == 0)
211 tensorData = readFromFile ?
212 ParseDataArray<armnn::DataType::Signed32>(inputTensorFile) :
213 GenerateDummyTensorData<armnn::DataType::Signed32>(numElements);
215 else if (dataTypeStr.compare(
"qasymm8") == 0)
217 tensorData = readFromFile ?
218 ParseDataArray<armnn::DataType::QAsymmU8>(inputTensorFile) :
219 GenerateDummyTensorData<armnn::DataType::QAsymmU8>(numElements);
223 std::string errorMessage =
"Unsupported tensor data type " + dataTypeStr;
226 inputTensorFile.close();
230 inputTensorFile.close();
235 if (!fs::exists(file))
237 std::cerr <<
"Given file path '" << file <<
"' does not exist" << std::endl;
240 if (!fs::is_regular_file(file) && expectFile)
242 std::cerr <<
"Given file path '" << file <<
"' is not a regular file" << std::endl;
248 bool ValidatePaths(
const std::vector<std::string>& fileVec,
const bool expectFile)
250 bool allPathsValid =
true;
251 for (
auto const& file : fileVec)
255 allPathsValid =
false;
258 return allPathsValid;
float Dequantize(QuantizedType value, float scale, int32_t offset)
Dequantize an 8-bit data type into a floating point data type.
std::vector< unsigned int > ParseArray(std::istream &stream)
void operator()(const std::vector< float > &values)
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.
mapbox::util::variant< std::vector< float >, std::vector< int >, std::vector< unsigned char > > TContainer
#define ARMNN_LOG(severity)
std::vector< T > GenerateDummyTensorData(unsigned int numElements)
void PopulateTensorWithData(TContainer &tensorData, unsigned int numElements, const std::string &dataTypeStr, const armnn::Optional< QuantizationParams > &qParams, const armnn::Optional< std::string > &dataFile)
std::string StringTrimCopy(const std::string &str, const std::string &chars="\\\")
Trim from both the start and the end of a string, returns a trimmed copy of the string.
auto ParseDataArray(std::istream &stream)
bool has_value() const noexcept
bool ValidatePaths(const std::vector< std::string > &fileVec, const bool expectFile)
Verifies if a given vector of strings are valid paths.
TensorPrinter(const std::string &binding, const armnn::TensorInfo &info, const std::string &outputTensorFile, bool dequantizeOutput)
Base class for all ArmNN exceptions so that users can filter to just those.
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
bool ValidatePath(const std::string &file, const bool expectFile)
Verifies if the given string is a valid path.
std::pair< float, int32_t > QuantizationParams