InDetGNNHardScatterSelection::GNN Class Reference

Implementation of the GNN used by the InDetGNNHardScatterSelection::GNNTool. More...

#include <GNN.h>

Collaboration diagram for InDetGNNHardScatterSelection::GNN:

Classes
struct	Decorators

Public Member Functions
	GNN (const std::string &nnFile)
	GNN (GNN &&)=delete
	GNN (const GNN &)=delete
virtual	~GNN ()
virtual float	decorate (const xAOD::Vertex &verrtex) const

Private Types
using	TPC = xAOD::TrackParticleContainer
using	TrackLinks = std::vector<ElementLink<TPC>>
template<typename T>
using	Dec = SG::AuxElement::Decorator<T>
template<typename T>
using	Decs = std::vector<std::pair<std::string, Dec<T>>>

Private Member Functions
std::set< std::string >	createDecorators (const FlavorTagInference::OutputConfig &outConfig)

Private Attributes
std::shared_ptr< const FlavorTagInference::SaltModel >	m_saltModel
std::string	m_modelPath
std::string	m_input_node_name
std::vector< internal::VarFromVertex >	m_varsFromVertex
std::vector< std::shared_ptr< IConstituentsLoader > >	m_constituentsLoaders
Decorators	m_decorators
float	m_defaultValue {}

Detailed Description

Implementation of the GNN used by the InDetGNNHardScatterSelection::GNNTool.

NOTE: The GNN relies on decorations added in InDetGNNHardScatterSelection::VertexDecoratorAlg and as such should only be called from within that algorithm

Author

Jackson Burzynski jacks.nosp@m.on.c.nosp@m.arl.b.nosp@m.urzy.nosp@m.nski@.nosp@m.cern.nosp@m..ch

Definition at line 43 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

Member Typedef Documentation

Dec

template<typename T>

using InDetGNNHardScatterSelection::GNN::Dec = SG::AuxElement::Decorator<T>

private

Definition at line 59 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

Decs

template<typename T>

using InDetGNNHardScatterSelection::GNN::Decs = std::vector<std::pair<std::string, Dec<T>>>

private

Definition at line 62 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

TPC

using InDetGNNHardScatterSelection::GNN::TPC = xAOD::TrackParticleContainer

private

Definition at line 55 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

TrackLinks

using InDetGNNHardScatterSelection::GNN::TrackLinks = std::vector<ElementLink<TPC>>

private

Definition at line 56 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

Constructor & Destructor Documentation

GNN() [1/3]

InDetGNNHardScatterSelection::GNN::GNN

(

const std::string &

nnFile

)

Definition at line 28 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/Root/GNN.cxx.

                                  :
    m_saltModel(nullptr),
    m_modelPath(),
    m_input_node_name()
  {
 
    // Load and initialize the neural network model from the given file path.
    std::string fullPathToOnnxFile = PathResolverFindCalibFile(nn_file);
    m_modelPath = fullPathToOnnxFile;
    m_saltModel = std::make_shared<FlavorTagInference::SaltModel>(fullPathToOnnxFile);
    auto graph_config = m_saltModel->getGraphConfig();
 
    // Vertex tensor key for runInference: must match InputNodeConfig::name in embedded gnn_config
    // (same metadata SaltModel uses for graph_config).
    std::vector<std::string> input_node_names;
    input_node_names.reserve(graph_config.inputs.size());
    for (const auto& node : graph_config.inputs) {
      input_node_names.push_back(node.name);
    }
 
    if (std::find(input_node_names.begin(), input_node_names.end(), "vertice_features") != input_node_names.end()) {
      m_input_node_name = "vertice_features";
    } else if (std::find(input_node_names.begin(), input_node_names.end(), "vertex_features") != input_node_names.end()) {
      m_input_node_name = "vertex_features";
    } else if (graph_config.inputs.size() == 1) {
      m_input_node_name = graph_config.inputs.front().name;
    } else {
      std::ostringstream msg;
      msg << "Unsupported scalar vertex input name in model '" << nn_file << "'. Graph config inputs: ";
      for (const auto& name : input_node_names) {
        msg << name << " ";
      }
      throw std::runtime_error(msg.str());
    }
 
    // Create configuration objects for data preprocessing.
    auto [inputs, constituents_configs] = dataprep::createGetterConfig(graph_config);
    
    for (const auto& config : constituents_configs){
      switch (config.type){
      case ConstituentsType::TRACK:
        m_constituentsLoaders.push_back(std::make_shared<TracksLoader>(config));
        break;
      case ConstituentsType::ELECTRON:
        m_constituentsLoaders.push_back(std::make_shared<ElectronsLoader>(config));
        break;
      case ConstituentsType::MUON:
        m_constituentsLoaders.push_back(std::make_shared<MuonsLoader>(config));
        break;
      case ConstituentsType::JET:
        m_constituentsLoaders.push_back(std::make_shared<JetsLoader>(config));
        break;
      case ConstituentsType::PHOTON:
        m_constituentsLoaders.push_back(std::make_shared<PhotonsLoader>(config));
        break;
      case ConstituentsType::IPARTICLE:
        m_constituentsLoaders.push_back(std::make_shared<IParticlesLoader>(config));
        break;
      }
    }
 
    m_varsFromVertex = dataprep::createVertexVarGetters(inputs);
 
    // Retrieve the configuration for the model outputs.
    FlavorTagInference::OutputConfig gnn_output_config = m_saltModel->getOutputConfig();
 
    for (const auto& outNode : gnn_output_config) {
      // the node's output name will be used to define the decoration name
      std::string dec_name = outNode.name;
      m_decorators.vertexFloat.emplace_back(outNode.name, Dec<float>(dec_name));
      if (outNode.name == "salt_phsvertex") {
        m_decorators.vertexFloat.emplace_back("salt_phsvertex", Dec<float>("HSGN2_phsvertex"));
      }
    }
  }

GNN() [2/3]

InDetGNNHardScatterSelection::GNN::GNN ( GNN && )

delete

GNN() [3/3]

InDetGNNHardScatterSelection::GNN::GNN ( const GNN & )

delete

~GNN()

InDetGNNHardScatterSelection::GNN::~GNN ( )

virtualdefault

Member Function Documentation

createDecorators()

std::set< std::string > InDetGNNHardScatterSelection::GNN::createDecorators ( const FlavorTagInference::OutputConfig & outConfig )

private

decorate()

float InDetGNNHardScatterSelection::GNN::decorate ( const xAOD::Vertex & verrtex ) const

virtual

Definition at line 106 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/Root/GNN.cxx.

                                                    {
    /* Main function for decorating a vertex with GNN outputs. */
    using namespace internal;
 
    // prepare input
    // -------------
    FlavorTagInference::InputMap gnn_input;
 
    std::vector<float> vertex_feat;
    vertex_feat.reserve(m_varsFromVertex.size());
    for (const auto& getter: m_varsFromVertex) {
      vertex_feat.push_back(getter(vertex).second);
    }
    std::vector<int64_t> vertexfeat_dim = {1, static_cast<int64_t>(vertex_feat.size())};
 
    for (const auto& value : vertex_feat) {
      if (!std::isfinite(value)) {
        throw std::runtime_error("Non-finite scalar vertex input before runInference");
      }
    }
 
    FlavorTagInference::Inputs vertex_info (vertex_feat, vertexfeat_dim);
    gnn_input.insert({m_input_node_name, vertex_info});
    // Provide common scalar aliases to absorb metadata/model naming mismatches.
    constexpr std::array<const char*, 4> scalar_input_aliases = {
      "vertice_features", "vertex_features", "vertice_var", "vertex_var"
    };
    for (const char* alias : scalar_input_aliases) {
      gnn_input.insert({alias, vertex_info});
    }
 
    for (const auto& loader : m_constituentsLoaders){
      auto [sequence_name, sequence_data, sequence_constituents] = loader->getData(vertex);
      gnn_input.insert({sequence_name, sequence_data});
      const std::string legacy_sequence_name = loader->getName();
      if (legacy_sequence_name != sequence_name) {
        gnn_input.insert({legacy_sequence_name, sequence_data});
      }
    }
 
    // run inference
    // -------------
    // FPE warning are hidden but should be resolved.
    // Related JIRA Ticket : https://its.cern.ch/jira/browse/ATLASRECTS-8386
    std::feclearexcept(FE_ALL_EXCEPT);
 
    const FlavorTagInference::InferenceOutput inference_output =
      m_saltModel->runInference(gnn_input);
    const auto& out_f = inference_output.singleFloat;
 
    // Get HSGNN score
    // ----------------
    float score = -999;
    FlavorTagInference::OutputConfig gnn_output_config = m_saltModel->getOutputConfig();
 
    for (const auto& outNode : gnn_output_config) {
      std::string score_name = outNode.name;
 
      if (outNode.name.find("_phsvertex") != std::string::npos) {
        score = out_f.at(score_name);
      }
    }
    std::feclearexcept(FE_ALL_EXCEPT);
 
    return score;
    
  } // end of decorate()

Member Data Documentation

m_constituentsLoaders

std::vector<std::shared_ptr<IConstituentsLoader> > InDetGNNHardScatterSelection::GNN::m_constituentsLoaders

private

Definition at line 75 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

m_decorators

Decorators InDetGNNHardScatterSelection::GNN::m_decorators

private

Definition at line 76 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

m_defaultValue

float InDetGNNHardScatterSelection::GNN::m_defaultValue {}

private

Definition at line 77 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

{};

m_input_node_name

std::string InDetGNNHardScatterSelection::GNN::m_input_node_name

private

Definition at line 73 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

m_modelPath

std::string InDetGNNHardScatterSelection::GNN::m_modelPath

private

Definition at line 72 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

m_saltModel

std::shared_ptr<const FlavorTagInference::SaltModel> InDetGNNHardScatterSelection::GNN::m_saltModel

private

Definition at line 71 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

m_varsFromVertex

std::vector<internal::VarFromVertex> InDetGNNHardScatterSelection::GNN::m_varsFromVertex

private

Definition at line 74 of file InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h.

---

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

• InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/InDetGNNHardScatterSelection/GNN.h
• InnerDetector/InDetRecTools/InDetGNNHardScatterSelection/Root/GNN.cxx