Wrapper around ONNXUtil to compute the output score of a model. More...

#include <TauGNN.h>

Inheritance diagram for TauGNN:

Collaboration diagram for TauGNN:

Classes
struct	Config

Public Member Functions
	TauGNN (const std::string &nnFile, const Config &config)

	~TauGNN ()

std::tuple< std::map< std::string, float >, std::map< std::string, std::vector< char > >, std::map< std::string, std::vector< float > > >	compute (const xAOD::TauJet &tau, const std::vector< const xAOD::TauTrack * > &tracks, const std::vector< xAOD::CaloVertexedTopoCluster > &clusters) const

bool	calculateInputVariables (const xAOD::TauJet &tau, const std::vector< const xAOD::TauTrack * > &tracks, const std::vector< xAOD::CaloVertexedTopoCluster > &clusters, std::map< std::string, std::map< std::string, double >> &scalarInputs, std::map< std::string, std::map< std::string, std::vector< double >>> &vectorInputs) const

const TauGNNUtils::GNNVarCalc *	variable_calculator () const

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Public Attributes
std::shared_ptr< const FlavorTagDiscriminants::OnnxUtil >	m_onnxUtil

FlavorTagDiscriminants::OnnxUtil::OutputConfig	gnn_output_config

Private Types
using	Inputs = FlavorTagDiscriminants::Inputs

using	VariableMap = std::map< std::string, double >

using	VectorMap = std::map< std::string, std::vector< double > >

using	InputMap = std::map< std::string, VariableMap >

using	InputSequenceMap = std::map< std::string, VectorMap >

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
const Config	m_config

std::vector< std::string >	m_scalar_inputs

std::vector< std::string >	m_track_inputs

std::vector< std::string >	m_cluster_inputs

std::vector< std::string >	m_scalarCalc_inputs

std::vector< std::string >	m_trackCalc_inputs

std::vector< std::string >	m_clusterCalc_inputs

std::unique_ptr< TauGNNUtils::GNNVarCalc >	m_var_calc

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Wrapper around ONNXUtil to compute the output score of a model.

Configures the network and computes the network outputs given the input objects. Retrieval of input variables is handled internally.

Author: N.M. Tamir

Definition at line 36 of file TauGNN.h.

Member Typedef Documentation

◆ InputMap

using TauGNN::InputMap = std::map<std::string, VariableMap>

private

Definition at line 81 of file TauGNN.h.

◆ Inputs

using TauGNN::Inputs = FlavorTagDiscriminants::Inputs

private

Definition at line 76 of file TauGNN.h.

◆ InputSequenceMap

using TauGNN::InputSequenceMap = std::map<std::string, VectorMap>

private

Definition at line 82 of file TauGNN.h.

◆ VariableMap

using TauGNN::VariableMap = std::map<std::string, double>

private

Definition at line 78 of file TauGNN.h.

◆ VectorMap

using TauGNN::VectorMap = std::map<std::string, std::vector<double> >

private

Definition at line 79 of file TauGNN.h.

Constructor & Destructor Documentation

◆ TauGNN()

TauGNN::TauGNN	(	const std::string &	nnFile,
		const Config &	config
	)

Definition at line 15 of file TauGNN.cxx.

                                                            :
     asg::AsgMessaging("TauGNN"),
     m_onnxUtil(std::make_shared<FlavorTagDiscriminants::OnnxUtil>(nnFile)),
     m_config{config}
   {
     //==================================================//
     // This part is ported from FTagDiscriminant GNN.cxx//
     //==================================================//
  
     // get the configuration of the model outputs
     FlavorTagDiscriminants::OnnxUtil::OutputConfig gnn_output_config = m_onnxUtil->getOutputConfig();
     
     //Let's see the output!
     for (const auto& out_node: gnn_output_config) {
         if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::FLOAT) ATH_MSG_INFO("Found output FLOAT node named:" << out_node.name);
         if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::VECCHAR) ATH_MSG_INFO("Found output VECCHAR node named:" << out_node.name);
         if(out_node.type==FlavorTagDiscriminants::OnnxOutput::OutputType::VECFLOAT) ATH_MSG_INFO("Found output VECFLOAT node named:" << out_node.name);
     }
  
     //Get model config (for inputs)
     auto lwtnn_config = m_onnxUtil->getLwtConfig();
     
     //===================================================//
     // This part is ported from tauRecTools TauJetRNN.cxx//
     //===================================================//
  
     // Search for input layer names specified in 'config'
     auto node_is_scalar = [&config](const lwt::InputNodeConfig &in_node) {
         return in_node.name == config.input_layer_scalar;
     };
     auto node_is_track = [&config](const lwt::InputNodeConfig &in_node) {
         return in_node.name == config.input_layer_tracks;
     };
     auto node_is_cluster = [&config](const lwt::InputNodeConfig &in_node) {
         return in_node.name == config.input_layer_clusters;
     };
  
     auto scalar_node = std::find_if(lwtnn_config.inputs.cbegin(),
                                     lwtnn_config.inputs.cend(),
                                     node_is_scalar);
  
     auto track_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
                                    lwtnn_config.input_sequences.cend(),
                                    node_is_track);
  
     auto cluster_node = std::find_if(lwtnn_config.input_sequences.cbegin(),
                                      lwtnn_config.input_sequences.cend(),
                                      node_is_cluster);
  
     // Check which input layers were found
     auto has_scalar_node = scalar_node != lwtnn_config.inputs.cend();
     auto has_track_node = track_node != lwtnn_config.input_sequences.cend();
     auto has_cluster_node = cluster_node != lwtnn_config.input_sequences.cend();
     if(!has_scalar_node) ATH_MSG_WARNING("No scalar node with name "<<config.input_layer_scalar<<" found!");
     if(!has_track_node) ATH_MSG_WARNING("No track node with name "<<config.input_layer_tracks<<" found!");
     if(!has_cluster_node) ATH_MSG_WARNING("No cluster node with name "<<config.input_layer_clusters<<" found!");
     
     // Fill the variable names of each input layer into the corresponding vector
     if (has_scalar_node) {
         for (const auto &in : scalar_node->variables) {
             std::string name = in.name;
             m_scalarCalc_inputs.push_back(name);
         }
     }
  
     if (has_track_node) {
         for (const auto &in : track_node->variables) {
             std::string name = in.name;
             m_trackCalc_inputs.push_back(name);
         }
     }
  
     if (has_cluster_node) {
         for (const auto &in : cluster_node->variables) {
             std::string name = in.name;
             m_clusterCalc_inputs.push_back(name);
         }
     }
     // Load the variable calculator
     m_var_calc = TauGNNUtils::get_calculator(m_scalarCalc_inputs, m_trackCalc_inputs, m_clusterCalc_inputs);
     ATH_MSG_INFO("TauGNN object initialized successfully!");
 }

◆ ~TauGNN()

TauGNN::~TauGNN ( )

Definition at line 98 of file TauGNN.cxx.

98 {}

Member Function Documentation

◆ calculateInputVariables()

bool TauGNN::calculateInputVariables	(	const xAOD::TauJet &	tau,
		const std::vector< const xAOD::TauTrack * > &	tracks,
		const std::vector< xAOD::CaloVertexedTopoCluster > &	clusters,
		std::map< std::string, std::map< std::string, double >> &	scalarInputs,
		std::map< std::string, std::map< std::string, std::vector< double >>> &	vectorInputs
	)		const

Definition at line 167 of file TauGNN.cxx.

                                                                                                {
     scalarInputs.clear();
     vectorInputs.clear();
     // Populate input (sequence) map with input variables
     for (const auto &varname : m_scalarCalc_inputs) {
         if (!m_var_calc->compute(varname, tau,
                                  scalarInputs[m_config.input_layer_scalar][varname])) {
             ATH_MSG_WARNING("Error computing '" << varname
                             << "' returning default");
             return false;
         }
     }
  
     for (const auto &varname : m_trackCalc_inputs) {
         if (!m_var_calc->compute(varname, tau, tracks,
                                  vectorInputs[m_config.input_layer_tracks][varname])) {
             ATH_MSG_WARNING("Error computing '" << varname
                             << "' returning default");
             return false;
         }
     }
  
     for (const auto &varname : m_clusterCalc_inputs) {
         if (!m_var_calc->compute(varname, tau, clusters,
                                  vectorInputs[m_config.input_layer_clusters][varname])) {
             ATH_MSG_WARNING("Error computing '" << varname
                             << "' returning default");
             return false;
         }
     }
     return true;
 }

◆ compute()

std::tuple< std::map< std::string, float >, std::map< std::string, std::vector< char > >, std::map< std::string, std::vector< float > > > TauGNN::compute	(	const xAOD::TauJet &	tau,
		const std::vector< const xAOD::TauTrack * > &	tracks,
		const std::vector< xAOD::CaloVertexedTopoCluster > &	clusters
	)		const

Definition at line 104 of file TauGNN.cxx.

                                                                       {
     InputMap scalarInputs;
     InputSequenceMap vectorInputs;
     std::map<std::string, Inputs> gnn_input;
     ATH_MSG_DEBUG("Starting compute...");
     //Prepare input variables
     if (!calculateInputVariables(tau, tracks, clusters, scalarInputs, vectorInputs)) {
         ATH_MSG_FATAL("Failed calculateInputVariables");
         throw StatusCode::FAILURE;
     }
  
     // Add TauJet-level features to the input
     std::vector<float> tau_feats;
     for (const auto &varname : m_scalarCalc_inputs) {
         tau_feats.push_back(static_cast<float>(scalarInputs[m_config.input_layer_scalar][varname]));
     }
     std::vector<int64_t> tau_feats_dim = {1, static_cast<int64_t>(tau_feats.size())};
     Inputs tau_info (tau_feats, tau_feats_dim);
     gnn_input.insert({"tau_vars", tau_info});
  
     //Add track-level features to the input
     std::vector<float> trk_feats;
     int num_nodes=static_cast<int>(vectorInputs[m_config.input_layer_tracks][m_trackCalc_inputs.at(0)].size());
     int num_node_vars=static_cast<int>(m_trackCalc_inputs.size());
     trk_feats.resize(num_nodes * num_node_vars);
     int var_idx=0;
     for (const auto &varname : m_trackCalc_inputs) {
         for (int node_idx=0; node_idx<num_nodes; node_idx++){    
             trk_feats.at(node_idx*num_node_vars + var_idx)
               = static_cast<float>(vectorInputs[m_config.input_layer_tracks][varname].at(node_idx));
         }
         var_idx++;
     }
     std::vector<int64_t> trk_feats_dim = {num_nodes, num_node_vars};
     Inputs trk_info (trk_feats, trk_feats_dim);
     gnn_input.insert({"track_vars", trk_info});
     
     //Add cluster-level features to the input
     std::vector<float> cls_feats;
     num_nodes=static_cast<int>(vectorInputs[m_config.input_layer_clusters][m_clusterCalc_inputs.at(0)].size());
     num_node_vars=static_cast<int>(m_clusterCalc_inputs.size());
     cls_feats.resize(num_nodes * num_node_vars);
     var_idx=0;
     for (const auto &varname : m_clusterCalc_inputs) {
         for (int node_idx=0; node_idx<num_nodes; node_idx++){    
             cls_feats.at(node_idx*num_node_vars + var_idx)
               = static_cast<float>(vectorInputs[m_config.input_layer_clusters][varname].at(node_idx));
         }
         var_idx++;
     }
     std::vector<int64_t> cls_feats_dim = {num_nodes, num_node_vars};
     Inputs cls_info (cls_feats, cls_feats_dim);
     gnn_input.insert({"cluster_vars", cls_info});    
  
     //RUN THE INFERENCE!!!
     ATH_MSG_DEBUG("Prepared inputs, running inference...");
     auto [out_f, out_vc, out_vf] = m_onnxUtil->runInference(gnn_input);
     ATH_MSG_DEBUG("Finished compute!");
     return std::make_tuple(out_f, out_vc, out_vf);
 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

 {
   m_imsg = Athena::getMessageSvc();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                       {
 #ifndef XAOD_STANDALONE
       return ::AthMessaging::msg();
 #else // not XAOD_STANDALONE
       return m_msg;
 #endif // not XAOD_STANDALONE
    }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                           {
 #ifndef XAOD_STANDALONE
       return ::AthMessaging::msg( lvl );
 #else // not XAOD_STANDALONE
       m_msg << lvl;
       return m_msg;
 #endif // not XAOD_STANDALONE
    }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                        {
 #ifndef XAOD_STANDALONE
       return ::AthMessaging::msgLvl( lvl );
 #else // not XAOD_STANDALONE
       return m_msg.msgLevel( lvl );
 #endif // not XAOD_STANDALONE
    }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

 {
   m_lvl = lvl;
 }

◆ variable_calculator()

const TauGNNUtils::GNNVarCalc* TauGNN::variable_calculator ( ) const

inline

Definition at line 68 of file TauGNN.h.

                                                              {
         return m_var_calc.get();
     }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ gnn_output_config

FlavorTagDiscriminants::OnnxUtil::OutputConfig TauGNN::gnn_output_config

Definition at line 73 of file TauGNN.h.

◆ m_cluster_inputs

std::vector<std::string> TauGNN::m_cluster_inputs

private

Definition at line 90 of file TauGNN.h.

◆ m_clusterCalc_inputs

std::vector<std::string> TauGNN::m_clusterCalc_inputs

private

Definition at line 94 of file TauGNN.h.

◆ m_config

const Config TauGNN::m_config

private

Definition at line 85 of file TauGNN.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_onnxUtil

std::shared_ptr<const FlavorTagDiscriminants::OnnxUtil> TauGNN::m_onnxUtil

Definition at line 46 of file TauGNN.h.

◆ m_scalar_inputs

std::vector<std::string> TauGNN::m_scalar_inputs

private

Definition at line 88 of file TauGNN.h.

◆ m_scalarCalc_inputs

std::vector<std::string> TauGNN::m_scalarCalc_inputs

private

Definition at line 92 of file TauGNN.h.

◆ m_track_inputs

std::vector<std::string> TauGNN::m_track_inputs

private

Definition at line 89 of file TauGNN.h.

◆ m_trackCalc_inputs

std::vector<std::string> TauGNN::m_trackCalc_inputs

private

Definition at line 93 of file TauGNN.h.

◆ m_var_calc

std::unique_ptr<TauGNNUtils::GNNVarCalc> TauGNN::m_var_calc

private

Definition at line 97 of file TauGNN.h.

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

Classes

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ InputMap

◆ Inputs

◆ InputSequenceMap

◆ VariableMap

◆ VectorMap

Constructor & Destructor Documentation

◆ TauGNN()

◆ ~TauGNN()

Member Function Documentation

◆ calculateInputVariables()

◆ compute()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

◆ variable_calculator()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ gnn_output_config

◆ m_cluster_inputs

◆ m_clusterCalc_inputs

◆ m_config

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_onnxUtil

◆ m_scalar_inputs

◆ m_scalarCalc_inputs

◆ m_track_inputs

◆ m_trackCalc_inputs

◆ m_var_calc