AthOnnxUtils Namespace Reference

Functions
template<typename T >
std::vector< T >	flattenNestedVectors (const std::vector< std::vector< T >> &features)
void	getInputNodeInfo (const Ort::Session &session, std::vector< std::vector< int64_t > > &dataShape, std::vector< std::string > &nodeNames)
void	getOutputNodeInfo (const Ort::Session &session, std::vector< std::vector< int64_t > > &dataShape, std::vector< std::string > &nodeNames)
void	getNodeInfo (const Ort::Session &session, std::vector< std::vector< int64_t > > &dataShape, std::vector< std::string > &nodeNames, bool isInput)
int64_t	getTensorSize (const std::vector< int64_t > &dataShape)
void	inferenceWithIOBinding (Ort::Session &session, const std::vector< std::string > &inputNames, const std::vector< Ort::Value > &inputData, const std::vector< std::string > &outputNames, const std::vector< Ort::Value > &outputData)
template<typename T >
Ort::Value	createTensor (std::vector< T > &data, const std::vector< int64_t > &dataShape)

Function Documentation

createTensor()

template<typename T >

Ort::Value AthOnnxUtils::createTensor	(	std::vector< T > &	data,
		const std::vector< int64_t > &	dataShape
	)

Definition at line 78 of file OnnxUtils.h.

                                                                               {
  // Create a tensor from the data.
  Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
  return Ort::Value::CreateTensor<T>(memoryInfo, data.data(), data.size(), dataShape.data(), dataShape.size());
}

flattenNestedVectors()

template<typename T >

std::vector<T> AthOnnxUtils::flattenNestedVectors ( const std::vector< std::vector< T >> &  features )

inline

Definition at line 20 of file OnnxUtils.h.

                                                                                   {
  // 1. Compute the total size required.
  int total_size = 0;
  for (const auto& feature : features) total_size += feature.size();
 
  std::vector<T> flatten1D;
  flatten1D.reserve(total_size);
 
  for (const auto& feature : features)
    for (const auto& elem : feature)
      flatten1D.push_back(elem);
 
  return flatten1D;
}

getInputNodeInfo()

void AthOnnxUtils::getInputNodeInfo	(	const Ort::Session &	session,
		std::vector< std::vector< int64_t > > &	dataShape,
		std::vector< std::string > &	nodeNames
	)

Definition at line 33 of file OnnxUtils.cxx.

 {
    getNodeInfo(session, dataShape, nodeNames, true);
}

getNodeInfo()

void AthOnnxUtils::getNodeInfo	(	const Ort::Session &	session,
		std::vector< std::vector< int64_t > > &	dataShape,
		std::vector< std::string > &	nodeNames,
		bool	isInput
	)

Definition at line 9 of file OnnxUtils.cxx.

 {
    dataShape.clear();
    nodeNames.clear();
 
    size_t numNodes = isInput? session.GetInputCount(): session.GetOutputCount();
    dataShape.reserve(numNodes);
    nodeNames.reserve(numNodes);
 
    Ort::AllocatorWithDefaultOptions allocator;
    for( std::size_t i = 0; i < numNodes; i++ ) {
        Ort::TypeInfo typeInfo = isInput? session.GetInputTypeInfo(i): session.GetOutputTypeInfo(i);
        auto tensorInfo = typeInfo.GetTensorTypeAndShapeInfo();
        dataShape.emplace_back(tensorInfo.GetShape());
 
        auto nodeName = isInput? session.GetInputNameAllocated(i, allocator) : session.GetOutputNameAllocated(i, allocator);
        nodeNames.emplace_back(nodeName.get());
     }
}

getOutputNodeInfo()

void AthOnnxUtils::getOutputNodeInfo	(	const Ort::Session &	session,
		std::vector< std::vector< int64_t > > &	dataShape,
		std::vector< std::string > &	nodeNames
	)

Definition at line 41 of file OnnxUtils.cxx.

  {
    getNodeInfo(session, dataShape, nodeNames, false);
}

getTensorSize()

int64_t AthOnnxUtils::getTensorSize

(

const std::vector< int64_t > &

dataShape

)

Definition at line 73 of file OnnxUtils.cxx.

                                                          {
    int64_t size = 1;
    for (const auto& dim : dataShape) {
            size *= dim;
    }
    return size;
}

inferenceWithIOBinding()

void AthOnnxUtils::inferenceWithIOBinding	(	Ort::Session &	session,
		const std::vector< std::string > &	inputNames,
		const std::vector< Ort::Value > &	inputData,
		const std::vector< std::string > &	outputNames,
		const std::vector< Ort::Value > &	outputData
	)

Definition at line 49 of file OnnxUtils.cxx.

                                          {
    
    if (inputNames.empty()) {
        throw std::runtime_error("Onnxruntime input data maping cannot be empty");
    }
    assert(inputNames.size() == inputData.size());
 
    Ort::IoBinding iobinding(session);
    for(size_t idx = 0; idx < inputNames.size(); ++idx){
        iobinding.BindInput(inputNames[idx].data(), inputData[idx]);
    }
 
 
    for(size_t idx = 0; idx < outputNames.size(); ++idx){
        iobinding.BindOutput(outputNames[idx].data(), outputData[idx]);
    }
 
    session.Run(Ort::RunOptions{nullptr}, iobinding);
}