ldmx::ort::ONNXRuntime Class Reference

A convenience wrapper of the ONNXRuntime C++ API. More...

#include <ONNXRuntime.h>

Public Member Functions
	ONNXRuntime (const std::string &model_path, const ::Ort::SessionOptions *session_options=nullptr)
	Class constructor.
	ONNXRuntime (const ONNXRuntime &)=delete
ONNXRuntime &	operator= (const ONNXRuntime &)=delete
FloatArrays	run (const std::vector< std::string > &input_names, FloatArrays &input_values, const std::vector< std::string > &output_names={}, int64_t batch_size=1) const
	Run model inference and get outputs.
const std::vector< std::string > &	getOutputNames () const
	Get the names of all the output nodes.
const std::vector< int64_t > &	getOutputShape (const std::string &output_name) const
	Get the shape of a output node.

Private Attributes
std::unique_ptr<::Ort::Session >	session_
std::vector< std::string >	input_node_strings_
std::vector< const char * >	input_node_names_
std::map< std::string, std::vector< int64_t > >	input_node_dims_
std::vector< std::string >	output_node_strings_
std::vector< const char * >	output_node_names_
std::map< std::string, std::vector< int64_t > >	output_node_dims_

Static Private Attributes
::Ort::Env	env

Detailed Description

A convenience wrapper of the ONNXRuntime C++ API.

Definition at line 27 of file ONNXRuntime.h.

Constructor & Destructor Documentation

ONNXRuntime()

ldmx::ort::ONNXRuntime::ONNXRuntime	(	const std::string &	model_path,
		const ::Ort::SessionOptions *	session_options = nullptr )

Class constructor.

Parameters

model_path	Path to the ONNX model file.
session_options	Configuration options of the ONNXRuntime Session. Leave empty to use the default.

Member Function Documentation

getOutputNames()

const std::vector< std::string > & ldmx::ort::ONNXRuntime::getOutputNames

(

)

const

Get the names of all the output nodes.

Returns

A list of names of all the output nodes.

Definition at line 170 of file ONNXRuntime.cxx.

                                                              {
  if (session_) {
    return output_node_strings_;
  } else {
    throw std::runtime_error("ONNXRuntime session is not initialized!");
  }
}

getOutputShape()

const std::vector< int64_t > & ldmx::ort::ONNXRuntime::getOutputShape

(

const std::string &

output_name

)

const

Get the shape of a output node.

The 0th dim depends on the batch size, therefore is set to -1.

Parameters

output_name

Name of the output node.

Returns

The shape of the output node as a vector of integers.

Definition at line 178 of file ONNXRuntime.cxx.

                                        {
  auto iter = output_node_dims_.find(output_name);
  if (iter == output_node_dims_.end()) {
    throw std::runtime_error("Output name '" + output_name + "' is invalid!");
  } else {
    return iter->second;
  }
}

run()

FloatArrays ldmx::ort::ONNXRuntime::run	(	const std::vector< std::string > &	input_names,
		FloatArrays &	input_values,
		const std::vector< std::string > &	output_names = {},
		int64_t	batch_size = 1 ) const

Run model inference and get outputs.

Parameters

input_names	List of the names of the input nodes.
input_values	List of input arrays for each input node. The order of input_values must match input_names.
output_names	Names of the output nodes to get outputs from. Empty list means all output nodes.
batch_size	Number of samples in the batch. Each array in input_values must have a shape layout of (batch_size, ...).

Returns

A std::vector<std::vector<float>>, with the order matched to output_names. When output_names is empty, will return all outputs ordered as in getOutputNames().

Definition at line 100 of file ONNXRuntime.cxx.

                                                       {
  assert(input_names.size() == input_values.size());
  assert(batch_size > 0);
 
  // create input tensor objects from data values
  std::vector<Value> input_tensors;
  auto memory_info =
      MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
  for (const auto& name : input_node_strings_) {
    auto iter = std::find(input_names.begin(), input_names.end(), name);
    if (iter == input_names.end()) {
      throw std::runtime_error("Input '" + name + "' is not provided!");
    }
    auto value = input_values.begin() + (iter - input_names.begin());
    auto input_dims = input_node_dims_.at(name);
    if (input_dims.size() > 0) {
      input_dims[0] = batch_size;
    }
    auto expected_len = std::accumulate(input_dims.begin(), input_dims.end(), 1,
                                        std::multiplies<int64_t>());
    if (expected_len != (int64_t)value->size()) {
      throw std::runtime_error("Input array '" + name +
                               "' has a wrong size of " +
                               std::to_string(value->size()) + ", expected " +
                               std::to_string(expected_len));
    }
    auto input_tensor =
        Value::CreateTensor<float>(memory_info, value->data(), value->size(),
                                   input_dims.data(), input_dims.size());
    assert(input_tensor.IsTensor());
    input_tensors.emplace_back(std::move(input_tensor));
  }
 
  // set output node names; will get all outputs if `output_names` is not
  // provided
  std::vector<const char*> run_output_node_names;
  if (output_names.empty()) {
    run_output_node_names = output_node_names_;
  } else {
    for (const auto& name : output_names) {
      run_output_node_names.push_back(name.c_str());
    }
  }
 
  // run
  auto output_tensors =
      session_->Run(RunOptions{nullptr}, input_node_names_.data(),
                    input_tensors.data(), input_tensors.size(),
                    run_output_node_names.data(), run_output_node_names.size());
 
  // convert output to floats
  FloatArrays outputs;
  for (auto& output_tensor : output_tensors) {
    assert(output_tensor.IsTensor());
 
    // get output shape
    auto tensor_info = output_tensor.GetTensorTypeAndShapeInfo();
    auto length = tensor_info.GetElementCount();
 
    auto floatarr = output_tensor.GetTensorMutableData<float>();
    outputs.emplace_back(floatarr, floatarr + length);
  }
  assert(outputs.size() == run_output_node_names.size());
 
  return outputs;
}

Member Data Documentation

env

Env ldmx::ort::ONNXRuntime::env

staticprivate

Definition at line 75 of file ONNXRuntime.h.

input_node_dims_

std::map<std::string, std::vector<int64_t> > ldmx::ort::ONNXRuntime::input_node_dims_

private

Definition at line 80 of file ONNXRuntime.h.

input_node_names_

std::vector<const char*> ldmx::ort::ONNXRuntime::input_node_names_

private

Definition at line 79 of file ONNXRuntime.h.

input_node_strings_

std::vector<std::string> ldmx::ort::ONNXRuntime::input_node_strings_

private

Definition at line 78 of file ONNXRuntime.h.

output_node_dims_

std::map<std::string, std::vector<int64_t> > ldmx::ort::ONNXRuntime::output_node_dims_

private

Definition at line 84 of file ONNXRuntime.h.

output_node_names_

std::vector<const char*> ldmx::ort::ONNXRuntime::output_node_names_

private

Definition at line 83 of file ONNXRuntime.h.

output_node_strings_

std::vector<std::string> ldmx::ort::ONNXRuntime::output_node_strings_

private

Definition at line 82 of file ONNXRuntime.h.

session_

std::unique_ptr<::Ort::Session> ldmx::ort::ONNXRuntime::session_

private

Definition at line 76 of file ONNXRuntime.h.

---

The documentation for this class was generated from the following files:

• Tools/include/Tools/ONNXRuntime.h
• Tools/src/Tools/ONNXRuntime.cxx