SaltModel Class Reference

#include <SaltModel.h>

Collaboration diagram for SaltModel:

Public Member Functions
	SaltModel (const std::string &name)
	~SaltModel ()=default
void	initialize ()
void	runInference (const std::vector< std::vector< float > > &node_feat, std::vector< float > &effAllJet) const
void	runInference (const std::vector< std::vector< float > > &node_feat, std::vector< std::vector< float > > &effAllJetAllWp) const

Private Attributes
std::vector< std::string >	m_input_node_names
std::vector< std::string >	m_output_node_names
std::unique_ptr< Ort::Session >	m_session
std::unique_ptr< Ort::Env >	m_env
std::string	m_path_to_onnx
int	m_num_wp {}

Detailed Description

Definition at line 14 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

Constructor & Destructor Documentation

SaltModel()

SaltModel::SaltModel

(

const std::string &

name

)

Definition at line 12 of file OnnxUtil.cxx.

  : m_path_to_onnx (name)
{
}

~SaltModel()

SaltModel::~SaltModel ( )

default

Member Function Documentation

initialize()

void SaltModel::initialize

(

)

Definition at line 17 of file OnnxUtil.cxx.

                          {
 
    std::string fullPathToFile = PathResolverFindCalibFile(m_path_to_onnx);
 
    //load the onnx model to memory using the path m_path_to_onnx
    m_env = std::make_unique< Ort::Env >(ORT_LOGGING_LEVEL_WARNING, "");
 
    // initialize session options if needed
    Ort::SessionOptions session_options;
    session_options.SetIntraOpNumThreads(1);
    session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
 
    // create session and load model into memory
    m_session = std::make_unique< Ort::Session >(*m_env, fullPathToFile.c_str(), session_options);
    Ort::AllocatorWithDefaultOptions allocator;
 
    // get the input nodes
    size_t num_input_nodes = m_session->GetInputCount();
    
    // iterate over all input nodes
    for (std::size_t i = 0; i < num_input_nodes; i++) {
    auto input_name = m_session->GetInputNameAllocated(i, allocator);
        m_input_node_names.emplace_back(input_name.get());
    }
 
    // get the output nodes
    size_t num_output_nodes = m_session->GetOutputCount();
    std::vector<int64_t> output_node_dims;
 
    // iterate over all output nodes
    for(std::size_t i = 0; i < num_output_nodes; i++ ) {
        auto output_name = m_session->GetOutputNameAllocated(i, allocator);
            m_output_node_names.emplace_back(output_name.get());
    
        // get output node types
        Ort::TypeInfo type_info = m_session->GetOutputTypeInfo(i);
        auto tensor_info = type_info.GetTensorTypeAndShapeInfo();
 
        output_node_dims = tensor_info.GetShape();
        
        // output is of the shape {1, num_jets, num_wp}
        m_num_wp = output_node_dims.at(2);
    }
}

runInference() [1/2]

void SaltModel::runInference	(	const std::vector< std::vector< float > > &	node_feat,
		std::vector< float > &	effAllJet ) const

Definition at line 64 of file OnnxUtil.cxx.

                                       {
 
    // Inputs:
    //    node_feat : vector<vector<float>>
    //    effAllJet : vector<double>&
 
    std::vector<float> input_tensor_values;
    std::vector<int64_t> input_node_dims = {1, static_cast<int>(node_feat.size()), static_cast<int>(node_feat.at(0).size())};
 
    for (const auto& it : node_feat){
        input_tensor_values.insert(input_tensor_values.end(), it.begin(), it.end());
    }
        
    // create input tensor object from data values
    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_values.size(), input_node_dims.data(), input_node_dims.size());
 
    // casting vector<string> to vector<const char*>. this is what ORT expects
    std::vector<const char*> input_node_names(m_input_node_names.size(),nullptr);
    for (unsigned int i=0; i<m_input_node_names.size(); i++) {
        input_node_names[i]= m_input_node_names.at(i).c_str();
    }
    std::vector<const char*> output_node_names(m_output_node_names.size(),nullptr);
    for (int i=0; i<static_cast<int>(m_output_node_names.size()); i++) {
        output_node_names[i]= m_output_node_names.at(i).c_str();
    }
 
    // score model & input tensor, get back output tensor
    // Although Session::Run is non-const, the onnx authors say
    // it is safe to call from multiple threads:
    //  https://github.com/microsoft/onnxruntime/discussions/10107
    Ort::Session& session ATLAS_THREAD_SAFE = *m_session;
    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_node_names.data(), &input_tensor, input_node_names.size(), output_node_names.data(), output_node_names.size());
 
    // set the output vector values to the inference results
    float* float_ptr = output_tensors.front().GetTensorMutableData<float>();
    int num_jets = node_feat.size();
    effAllJet = {float_ptr, float_ptr + num_jets};
}

runInference() [2/2]

void SaltModel::runInference	(	const std::vector< std::vector< float > > &	node_feat,
		std::vector< std::vector< float > > &	effAllJetAllWp ) const

Definition at line 108 of file OnnxUtil.cxx.

                                                       {
 
    // Inputs:
    //    node_feat      : vector<vector<float>>
    //    effAllJetAllWp : vector<vector<double>>& shape:{num_jets, num_wp}
 
    // using float because that's what the model expects
    // ort exectues type casting wrong (x = x.float()), so can't change the type inside the model
    std::vector<float> input_tensor_values;
    std::vector<int64_t> input_node_dims = {1, static_cast<int>(node_feat.size()), static_cast<int>(node_feat.at(0).size())};
 
    for (auto& it : node_feat){
        input_tensor_values.insert(input_tensor_values.end(), it.begin(), it.end());
    }
        
    // create input tensor object from data values
    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_tensor_values.data(), input_tensor_values.size(), input_node_dims.data(), input_node_dims.size());
    
    // casting vector<string> to vector<const char*>. this is what ORT expects
    std::vector<const char*> input_node_names(m_input_node_names.size(),nullptr);
    for (int i=0; i<static_cast<int>(m_input_node_names.size()); i++) {
        input_node_names[i]= m_input_node_names.at(i).c_str();
    }
    std::vector<const char*> output_node_names(m_output_node_names.size(),nullptr);
    for (int i=0; i<static_cast<int>(m_output_node_names.size()); i++) {
        output_node_names[i]= m_output_node_names.at(i).c_str();
    }
 
    // score model & input tensor, get back output tensor
    // Although Session::Run is non-const, the onnx authors say
    // it is safe to call from multiple threads:
    //  https://github.com/microsoft/onnxruntime/discussions/10107
    Ort::Session& session ATLAS_THREAD_SAFE = *m_session;
    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_node_names.data(), &input_tensor, input_node_names.size(), output_node_names.data(), output_node_names.size());
    
    // set the output vector values to the inference results
    float* float_ptr = output_tensors.front().GetTensorMutableData<float>();
 
    int num_jets = node_feat.size();
 
    for (int i=0; i<num_jets; i++){
        std::vector<float> eff_one_jet_tmp;
        for (int j=0; j<m_num_wp; j++){
            eff_one_jet_tmp.push_back(float_ptr[i*m_num_wp+j]);
        }
        effAllJetAllWp.push_back(std::move(eff_one_jet_tmp));
    }
}

Member Data Documentation

m_env

std::unique_ptr< Ort::Env > SaltModel::m_env

private

Definition at line 41 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

m_input_node_names

std::vector<std::string> SaltModel::m_input_node_names

private

Definition at line 38 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

m_num_wp

int SaltModel::m_num_wp {}

private

Definition at line 46 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

{};

m_output_node_names

std::vector<std::string> SaltModel::m_output_node_names

private

Definition at line 39 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

m_path_to_onnx

std::string SaltModel::m_path_to_onnx

private

Definition at line 43 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

m_session

std::unique_ptr< Ort::Session > SaltModel::m_session

private

Definition at line 40 of file JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h.

---

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

• JetTagPerformanceCalibration/xAODBTaggingEfficiency/xAODBTaggingEfficiency/SaltModel.h
• OnnxUtil.cxx