sopt::ORTsession Class Reference

Sopt interface class to hold a ONNXrt session. More...

#include <ort_session.h>

Public Member Functions
	ORTsession ()=delete
	ORTsession (const std::string &filename, const std::string &runname="soptONNXrt")
	Constructor. More...
std::vector< float >	compute (std::vector< float > &inputs, const std::vector< int64_t > &inDims) const
template<typename T = t_real>
Vector< T >	compute (const Vector< T > &input, const std::vector< int64_t > &inDims) const
	Variant of compute() using input/output Eigen arrays. More...
template<typename T = t_real>
Image< T >	compute (const Image< T > &input, std::vector< int64_t > inDims={}) const
	Variant of compute() using input/output Image. More...
const bool	hasKey (const std::string &key) const
	Method to check if key exists in network metadata. More...
template<typename T >
const T	retrieve (const std::string &key) const
template<typename T >
const T	retrieve (const std::string &key, const T &defaultreturn) const

Detailed Description

Sopt interface class to hold a ONNXrt session.

Definition at line 18 of file ort_session.h.

Constructor & Destructor Documentation

ORTsession() [1/2]

sopt::ORTsession::ORTsession ( )

delete

ORTsession() [2/2]

sopt::ORTsession::ORTsession ( const std::string &  filename, const std::string &  runname = "soptONNXrt"  )

inline

Constructor.

Definition at line 25 of file ort_session.h.

                                                                                 {
 
    // Set-up ONNXrt session
    _env = std::make_unique<Ort::Env>(ORT_LOGGING_LEVEL_WARNING, runname.c_str());
 
    // Load the model
    Ort::SessionOptions sessionopts;
 
    // Allow the number of threads used by the ONNX runtime to be set by an
    // environment variable. If unset it will use all available threads by default
    char* env_num_threads = std::getenv("ORT_NUM_THREADS");
    if(env_num_threads) {
      const int num_threads = std::stoi(env_num_threads);
      sessionopts.SetIntraOpNumThreads(num_threads);
      SOPT_INFO("ONNXRT using {} IntraOpThreads", num_threads);
    }
 
    _session = std::make_unique<Ort::Session>(*_env, filename.c_str(), sessionopts);
 
    // Store model hyperparameters (input/output shape etc.)
    _retrieveNetworkInfo();
  }

References SOPT_INFO.

Member Function Documentation

compute() [1/3]

template<typename T = t_real>

Image<T> sopt::ORTsession::compute ( const Image< T > &  input, std::vector< int64_t >  inDims = {}  ) const

inline

Variant of compute() using input/output Image.

Definition at line 113 of file ort_session.h.

                                                                      {}) const {
 
    // require an output node of the form {1, nRows, nCols}
    // in order to be able to map this onto a 2D tensor
    if (inDims.size() && inDims.size() != _inShape) {
      throw std::length_error("Input tensor has incorrect shape! Expected "+std::to_string(_inShape)+" dimensions.");
    }
 
    // ONNXrt requires floats as input
    const int nrows = input.rows();
    const int ncols = input.cols();
    std::vector<float> flat_input(nrows*ncols);
    for (int i = 0; i < nrows; ++i) {
      for (int j = 0; j < ncols; ++j) {
        flat_input[j*ncols+i] = input(i,j);
      }
    }
    if (inDims.empty()) {
      while (inDims.size() < _inShape-2)  inDims.push_back(1);
      inDims.push_back(nrows);
      inDims.push_back(ncols);
    }
    std::vector<float> flat_output = compute(flat_input, inDims);
 
    std::vector<T> tResults(flat_output.begin(), flat_output.end());
    Eigen::Map<Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>> rtn(tResults.data(), nrows, ncols);
    return rtn;
  }

compute() [2/3]

template<typename T = t_real>

Vector<T> sopt::ORTsession::compute ( const Vector< T > &  input, const std::vector< int64_t > &  inDims  ) const

inline

Variant of compute() using input/output Eigen arrays.

Definition at line 86 of file ort_session.h.

                                                                                    {
    // ONNXrt requires floats as input
    std::vector<float> flat_input(input.size());
    for (size_t i = 0; i < input.size(); ++i) {
      if constexpr(std::is_same<T, t_complex>::value) {
        flat_input[i] = input[i].real();
      } else {
        flat_input[i] = input[i];
      }
    }
    std::vector<float> flat_output = compute(flat_input, inDims);
    Vector<T> rtn(flat_output.size());
    for (size_t i = 0; i < flat_output.size(); ++i) {
      if constexpr(std::is_same<T, t_complex>::value)
      {
        rtn[i] = t_complex(flat_output[i], 0);
      }
      else
      {
        rtn[i] = flat_output[i];
      }
    }
    return rtn;
  }

References compute().

compute() [3/3]

std::vector<float> sopt::ORTsession::compute ( std::vector< float > &  inputs, const std::vector< int64_t > &  inDims  ) const

inline

Evaluates the network in the forward direction using a flattened tensor as input

Definition at line 50 of file ort_session.h.

                                                                                             {
 
    if (inputs.empty()) {
      throw std::length_error("Input vector is empty!");
    }
    if (inDims.size() != _inShape) {
      throw std::length_error("Input tensor has incorrect shape! Expected "+std::to_string(_inShape)+" dimensions.");
    }
 
    // reshape flat input vector as tensor and run the model
    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    auto input_tensor = Ort::Value::CreateTensor<float>(memory_info, inputs.data(), inputs.size(),
                                                        inDims.data(), inDims.size());
    auto output_tensors = _session->Run(Ort::RunOptions{nullptr}, _inNames.data(),
                                        &input_tensor, _inNames.size(),
                                        _outNames.data(), _outNames.size());
 
    // retrieve the ouput tensor and return flattened version
    auto outputInfo = output_tensors[0].GetTensorTypeAndShapeInfo();
    // Fix negative shape values - this appears to be an artefact of batch size issues
    int64_t outLen = 1;
    for (auto& dim : outputInfo.GetShape()) {
      if (dim < 0)  dim = abs(dim);
      outLen *= dim;
    }
    if (outLen == 0) {
      throw std::length_error("Invalid network structure: Output node with 0-length tensor encountered!");
    }
    float* floatarr = output_tensors.front().GetTensorMutableData<float>();
    std::vector<float> outputs;
    outputs.assign(floatarr, floatarr + outLen);
    return outputs;
  }

Referenced by compute(), sopt::ONNXDifferentiableFunc< SCALAR >::function(), sopt::ONNXDifferentiableFunc< SCALAR >::gradient(), and TEST_CASE().

hasKey()

const bool sopt::ORTsession::hasKey ( const std::string &  key ) const

inline

Method to check if key exists in network metadata.

Definition at line 143 of file ort_session.h.

                                                {
    Ort::AllocatorWithDefaultOptions allocator;
    return  (bool)_metadata->LookupCustomMetadataMapAllocated(key.c_str(), allocator);
  }

retrieve() [1/2]

template<typename T >

const T sopt::ORTsession::retrieve ( const std::string &  key ) const

inline

Method to retrieve value associated with key from network metadata and return value as type T

Definition at line 151 of file ort_session.h.

                                               {
    Ort::AllocatorWithDefaultOptions allocator;
    Ort::AllocatedStringPtr res = _metadata->LookupCustomMetadataMapAllocated(key.c_str(), allocator);
    if (!res) {
      throw std::runtime_error("Key '"+key+"' not found in network metadata!");
    }
    if constexpr (std::is_same<T, std::string>::value) {
      return res.get();
    }
    else {
      return utilities::lexical_cast<T>(res.get());
    }
  }

Referenced by TEST_CASE().

retrieve() [2/2]

template<typename T >

const T sopt::ORTsession::retrieve ( const std::string &  key, const T &  defaultreturn  ) const

inline

Variation of retrieve method that falls back to defaultreturn if key cannot be found

Definition at line 169 of file ort_session.h.

                                                                       {
    try {
      return retrieve<T>(key);
    } catch (std::exception& e) {
      return defaultreturn;
    }
  }

---

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

• /home/runner/work/sopt/sopt/cpp/sopt/ort_session.h