AthOnnx Namespace Reference

Namespace holding all of the Onnx Runtime example code. More...

Classes
class	EvaluateModel
	Algorithm demonstrating the usage of the ONNX Runtime C++ API. More...
class	IOnnxRuntimeInferenceTool
	Interface class for creating Onnx Runtime sessions. More...
class	IOnnxRuntimeSessionTool
class	IOnnxRuntimeSvc
	Service used for managing global objects used by Onnx Runtime. More...
class	OnnxRuntimeInferenceTool
class	OnnxRuntimeSessionToolCPU
class	OnnxRuntimeSessionToolCUDA
class	OnnxRuntimeSvc
	Service implementing AthOnnx::IOnnxRuntimeSvc. More...

Functions
std::vector< std::vector< std::vector< float > > >	read_mnist_pixel_notFlat (const std::string &full_path)
std::vector< int >	read_mnist_label (const std::string &full_path)
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)
Ort::Value	createTensor (std::vector< float > &data, const std::vector< int64_t > &dataShape)

Detailed Description

Namespace holding all of the Onnx Runtime example code.

Function Documentation

createTensor()

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

Definition at line 81 of file OnnxUtils.cxx.

{
    auto memoryInfo = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault); 
 
    return Ort::Value::CreateTensor<float>(
                                memoryInfo, 
                                data.data(), 
                                data.size(),  
                                dataShape.data(), 
                                dataShape.size());
};

flattenNestedVectors()

template<typename T >

std::vector<T> AthOnnx::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 AthOnnx::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 AthOnnx::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 AthOnnx::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 AthOnnx::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 AthOnnx::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);
}

read_mnist_label()

std::vector<int> AthOnnx::read_mnist_label

(

const std::string &

full_path

)

Definition at line 51 of file EvaluateModel.cxx.

   {
     std::vector<int> output_tensor_values(1*10000);
     std::ifstream file (full_path.c_str(), std::ios::binary);
     int magic_number=0;
     int number_of_labels=0;
     file.read((char*)&magic_number,sizeof(magic_number));
     magic_number= ntohl(magic_number);
     file.read((char*)&number_of_labels,sizeof(number_of_labels));
     number_of_labels= ntohl(number_of_labels);
     for(int i=0;i<number_of_labels;++i)
     {
          unsigned char temp=0;
          file.read((char*)&temp,sizeof(temp));
          output_tensor_values[i]= int(temp);
     }
      return output_tensor_values;
    }

read_mnist_pixel_notFlat()

std::vector<std::vector<std::vector<float> > > AthOnnx::read_mnist_pixel_notFlat

(

const std::string &

full_path

)

Definition at line 17 of file EvaluateModel.cxx.

   {
     std::vector<std::vector<std::vector<float>>> input_tensor_values;
     input_tensor_values.resize(10000, std::vector<std::vector<float> >(28,std::vector<float>(28)));
     std::ifstream file (full_path.c_str(), std::ios::binary);
     int magic_number=0;
     int number_of_images=0;
     int n_rows=0;
     int n_cols=0;
     file.read((char*)&magic_number,sizeof(magic_number));
     magic_number= ntohl(magic_number);
     file.read((char*)&number_of_images,sizeof(number_of_images));
     number_of_images= ntohl(number_of_images);
     file.read((char*)&n_rows,sizeof(n_rows));
     n_rows= ntohl(n_rows);
     file.read((char*)&n_cols,sizeof(n_cols));
     n_cols= ntohl(n_cols);
     for(int i=0;i<number_of_images;++i)
     {
        for(int r=0;r<n_rows;++r)
        {
           for(int c=0;c<n_cols;++c)
           {
             unsigned char temp=0;
             file.read((char*)&temp,sizeof(temp));
             input_tensor_values[i][r][c]= float(temp)/255;
           }
    }
     }
     return input_tensor_values;
   }