EventReco::HyPERTtbarDiLeptonModel Class Reference

This class is in charge of loading the correct HyPER model based on the Ttbar di-lepton topology. More...

#include <HyPERTtbarDiLeptonModel.h>

Inheritance diagram for EventReco::HyPERTtbarDiLeptonModel:

Collaboration diagram for EventReco::HyPERTtbarDiLeptonModel:

Public Member Functions
	HyPERTtbarDiLeptonModel (const AthOnnx::IOnnxRuntimeInferenceTool *trainedOnEven, const AthOnnx::IOnnxRuntimeInferenceTool *trainedOnOdd)
std::vector< std::string >	getInputNames () const override
	Input node names in the order the ONNX graph declares them.
std::vector< HyPEROutputNode >	getModelOutputs () const override
	Every output node of the ONNX graph, in declaration order.
std::vector< std::string >	getOutputNames () const override
	Model-specific output names consumed by the parser.
StatusCode	initialize ()
	Resolve the node name -> node index maps.
void	setTopology (HyPERTopology topology)=delete
HyPERTopology	getTopology () const
template<typename T>
void	setInputs (const std::string &node, std::vector< T > &values, const std::vector< int64_t > &shape)
	Bind an input by node name.
StatusCode	evaluate (unsigned sessionIndex)
	Run the model of the requested fold over the bound inputs.
template<typename T>
T *	getOutputs (const std::string &node)
	Pointer to the buffer of the named output.
void	clearInputs ()
void	clearOutputs ()
void	printInputInfo (bool printContent=false) const
void	printOutputInfo (bool printContent=false) const

Protected Attributes
HyPERTopology	m_topology {HyPERTopology::NotSelected}

Private Types
using	InputData = std::variant<std::vector<float>*, std::vector<int64_t>*>

Static Private Member Functions
template<typename T>
static std::string	contentToString (const std::vector< T > &values)
static std::string	shapeToString (const std::vector< int64_t > &shape)

Private Attributes
const AthOnnx::IOnnxRuntimeInferenceTool *	m_toolTrainedOnEven {nullptr}
const AthOnnx::IOnnxRuntimeInferenceTool *	m_toolTrainedOnOdd {nullptr}
std::map< std::string, std::size_t >	m_inputIndex {}
std::vector< BoundInput >	m_boundInputs {}
std::vector< HyPEROutputNode >	m_outputNodes {}
std::map< std::string, std::size_t >	m_outputIndex {}
std::vector< std::vector< float > >	m_outputsFloat {}
std::vector< std::vector< int64_t > >	m_outputsInt64 {}

Static Private Attributes
static constexpr const char *	s_edgeIndexName = "edge_index"
	Input nodes whose shapes carry the graph's dynamic dimensions.
static constexpr const char *	s_hyperEdgeIndexName = "edge_index_h"

Detailed Description

This class is in charge of loading the correct HyPER model based on the Ttbar di-lepton topology.

Definition at line 20 of file HyPERTtbarDiLeptonModel.h.

Member Typedef Documentation

InputData

using EventReco::HyPERModel::InputData = std::variant<std::vector<float>*, std::vector<int64_t>*>

privateinherited

Definition at line 289 of file HyPERModel.h.

Constructor & Destructor Documentation

HyPERTtbarDiLeptonModel()

EventReco::HyPERTtbarDiLeptonModel::HyPERTtbarDiLeptonModel ( const AthOnnx::IOnnxRuntimeInferenceTool * trainedOnEven, const AthOnnx::IOnnxRuntimeInferenceTool * trainedOnOdd )

inline

Definition at line 22 of file HyPERTtbarDiLeptonModel.h.

      : HyPERModel(trainedOnEven, trainedOnOdd, HyPERTopology::TtbarDiLepton) {}

Member Function Documentation

clearInputs()

void EventReco::HyPERModel::clearInputs ( )

inlineinherited

Definition at line 240 of file HyPERModel.h.

                     {
    for (BoundInput& bound : m_boundInputs) bound = BoundInput{};
  }

clearOutputs()

void EventReco::HyPERModel::clearOutputs ( )

inlineinherited

Definition at line 244 of file HyPERModel.h.

                      {
    for (std::vector<float>& out : m_outputsFloat) out.clear();
    for (std::vector<int64_t>& out : m_outputsInt64) out.clear();
  }

contentToString()

template<typename T>

std::string EventReco::HyPERModel::contentToString ( const std::vector< T > & values )

inlinestaticprivateinherited

Definition at line 297 of file HyPERModel.h.

                                                               {
    std::string row = "[";
    for (const T& value : values) row += std::to_string(value) + ", ";
    return row + "]";
  }

evaluate()

StatusCode EventReco::HyPERModel::evaluate ( unsigned sessionIndex )

inlineinherited

Run the model of the requested fold over the bound inputs.

Parameters

sessionIndex

0 for the model trained on even events, 1 for odd.

Definition at line 158 of file HyPERModel.h.

                                             {
    using namespace asg::msgUserCode;
 
    const AthOnnx::IOnnxRuntimeInferenceTool* tool =
        (sessionIndex == 0) ? m_toolTrainedOnEven : m_toolTrainedOnOdd;
 
    // Inputs, in the order the ONNX graph declares them.
    std::vector<Ort::Value> inputTensors;
    inputTensors.reserve(m_boundInputs.size());
    for (std::size_t i = 0; i < m_boundInputs.size(); ++i) {
      BoundInput& bound = m_boundInputs[i];
      if (!bound.set) {
        ANA_MSG_ERROR("HyPERModel: input node " << i << " was never set");
        return StatusCode::FAILURE;
      }
      if (std::holds_alternative<std::vector<float>*>(bound.data)) {
        inputTensors.push_back(AthOnnxUtils::createTensor(
            *std::get<std::vector<float>*>(bound.data), bound.shape));
      } else {
        inputTensors.push_back(AthOnnxUtils::createTensor(
            *std::get<std::vector<int64_t>*>(bound.data), bound.shape));
      }
    }
 
    // The graph's dynamic dimensions, taken from the shapes of the index
    // tensors: edge_index is {2, nEdges} and edge_index_h is {order, nHyper}.
    const int64_t nEdges =
        m_boundInputs[m_inputIndex.at(s_edgeIndexName)].shape.back();
    const int64_t nHyperEdges =
        m_boundInputs[m_inputIndex.at(s_hyperEdgeIndexName)].shape.back();
 
    // Outputs, also in declaration order. ONNX Runtime writes straight into
    // the buffers owned here, which getOutputs() then hands to the parser.
    std::vector<Ort::Value> outputTensors;
    outputTensors.reserve(m_outputNodes.size());
    for (std::size_t i = 0; i < m_outputNodes.size(); ++i) {
      const HyPEROutputNode& node = m_outputNodes[i];
      int64_t leading = 1;
      switch (node.dim) {
        case HyPEROutputDim::HyperEdges: leading = nHyperEdges; break;
        case HyPEROutputDim::Edges:      leading = nEdges;      break;
        case HyPEROutputDim::Single:     leading = 1;           break;
      }
      std::vector<int64_t> shape{leading};
      if (node.trailingOne) shape.push_back(1);
 
      const int64_t size = AthOnnxUtils::getTensorSize(shape);
      if (node.isFloat) {
        m_outputsFloat[i].assign(static_cast<std::size_t>(size), 0.f);
        outputTensors.push_back(
            AthOnnxUtils::createTensor(m_outputsFloat[i], shape));
      } else {
        m_outputsInt64[i].assign(static_cast<std::size_t>(size), 0);
        outputTensors.push_back(
            AthOnnxUtils::createTensor(m_outputsInt64[i], shape));
      }
    }
 
    return tool->inference(inputTensors, outputTensors);
  }

getInputNames()

std::vector< std::string > EventReco::HyPERTtbarDiLeptonModel::getInputNames ( ) const

inlineoverridevirtual

Input node names in the order the ONNX graph declares them.

The order matters: ONNX Runtime is handed the tensors positionally.

Implements EventReco::HyPERModel.

Definition at line 28 of file HyPERTtbarDiLeptonModel.h.

                                                      {
    return std::vector<std::string>{"x_s",           "edge_index",
                                    "edge_attr_s",   "u_s",
                                    "batch",         "edge_index_h",
                                    "batch_hyperedge"};
  }

getModelOutputs()

std::vector< HyPEROutputNode > EventReco::HyPERTtbarDiLeptonModel::getModelOutputs ( ) const

inlineoverridevirtual

Every output node of the ONNX graph, in declaration order.

Implements EventReco::HyPERModel.

Definition at line 38 of file HyPERTtbarDiLeptonModel.h.

                                                              {
    return std::vector<HyPEROutputNode>{
        {"hyperedge_prime", true, HyPEROutputDim::HyperEdges, true},
        {"batch_hyperedge", false, HyPEROutputDim::HyperEdges, false},
        {"edge_prime", true, HyPEROutputDim::Edges, true},
        {"classification_score", true, HyPEROutputDim::Single, true}};
  }

getOutputNames()

std::vector< std::string > EventReco::HyPERTtbarDiLeptonModel::getOutputNames ( ) const

inlineoverridevirtual

Model-specific output names consumed by the parser.

Output names vary according to the number of message-passing layers etc. This must be defined for each and every topology.

Returns

std::vector<std::string> The output names of the model

Implements EventReco::HyPERModel.

Definition at line 46 of file HyPERTtbarDiLeptonModel.h.

                                                       {
    return std::vector<std::string>{"hyperedge_prime", "edge_prime",
                                    "classification_score"};
  }

getOutputs()

template<typename T>

T * EventReco::HyPERModel::getOutputs ( const std::string & node )

inlineinherited

Pointer to the buffer of the named output.

Valid until the next clearOutputs() or evaluate().

Definition at line 224 of file HyPERModel.h.

                                       {
    using namespace asg::msgUserCode;
    static_assert(std::is_same_v<T, float> || std::is_same_v<T, int64_t>,
                  "HyPER ONNX outputs must be float or int64_t");
    const auto it = m_outputIndex.find(node);
    if (it == m_outputIndex.end()) {
      ANA_MSG_ERROR("HyPERModel: unknown output node '" << node << "'");
      return nullptr;
    }
    if constexpr (std::is_same_v<T, float>) {
      return m_outputsFloat[it->second].data();
    } else {
      return m_outputsInt64[it->second].data();
    }
  }

getTopology()

HyPERTopology EventReco::HyPERModel::getTopology ( ) const

inlineinherited

Definition at line 112 of file HyPERModel.h.

{ return m_topology; }

initialize()

StatusCode EventReco::HyPERModel::initialize ( )

inlineinherited

Resolve the node name -> node index maps.

Must be called once before the first evaluate(). This cannot live in the constructor because it relies on the topology-specific virtual methods below.

Definition at line 76 of file HyPERModel.h.

                          {
    using namespace asg::msgUserCode;
    if (!m_toolTrainedOnEven || !m_toolTrainedOnOdd) {
      ANA_MSG_ERROR("HyPERModel: ONNX inference tools have not been set");
      return StatusCode::FAILURE;
    }
 
    const std::vector<std::string> inputNames = getInputNames();
    m_inputIndex.clear();
    for (std::size_t i = 0; i < inputNames.size(); ++i) {
      m_inputIndex[inputNames[i]] = i;
    }
    m_boundInputs.assign(inputNames.size(), BoundInput{});
 
    m_outputNodes = getModelOutputs();
    m_outputIndex.clear();
    for (std::size_t i = 0; i < m_outputNodes.size(); ++i) {
      m_outputIndex[m_outputNodes[i].name] = i;
    }
    m_outputsFloat.assign(m_outputNodes.size(), std::vector<float>{});
    m_outputsInt64.assign(m_outputNodes.size(), std::vector<int64_t>{});
 
    // The dynamic output dimensions are read back off these two inputs.
    if (m_inputIndex.find(s_edgeIndexName) == m_inputIndex.end() ||
        m_inputIndex.find(s_hyperEdgeIndexName) == m_inputIndex.end()) {
      ANA_MSG_ERROR("HyPERModel: the input names must contain '"
                    << s_edgeIndexName << "' and '" << s_hyperEdgeIndexName
                    << "'");
      return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }

printInputInfo()

void EventReco::HyPERModel::printInputInfo ( bool printContent = false ) const

inlineinherited

Definition at line 249 of file HyPERModel.h.

                                                     {
    using namespace asg::msgUserCode;
    const std::vector<std::string> names = getInputNames();
    for (std::size_t i = 0; i < m_boundInputs.size(); ++i) {
      const BoundInput& bound = m_boundInputs[i];
      ANA_MSG_INFO("  input " << i << " '" << names[i]
                              << "' shape=" << shapeToString(bound.shape));
      if (!printContent || !bound.set) continue;
      if (std::holds_alternative<std::vector<float>*>(bound.data)) {
        ANA_MSG_INFO("    " << contentToString(
                         *std::get<std::vector<float>*>(bound.data)));
      } else {
        ANA_MSG_INFO("    " << contentToString(
                         *std::get<std::vector<int64_t>*>(bound.data)));
      }
    }
  }

printOutputInfo()

void EventReco::HyPERModel::printOutputInfo ( bool printContent = false ) const

inlineinherited

Definition at line 267 of file HyPERModel.h.

                                                      {
    using namespace asg::msgUserCode;
    for (std::size_t i = 0; i < m_outputNodes.size(); ++i) {
      ANA_MSG_INFO("  output " << i << " '" << m_outputNodes[i].name << "'");
      if (!printContent) continue;
      if (m_outputNodes[i].isFloat) {
        ANA_MSG_INFO("    " << contentToString(m_outputsFloat[i]));
      } else {
        ANA_MSG_INFO("    " << contentToString(m_outputsInt64[i]));
      }
    }
  }

setInputs()

template<typename T>

void EventReco::HyPERModel::setInputs ( const std::string & node, std::vector< T > & values, const std::vector< int64_t > & shape )

inlineinherited

Bind an input by node name.

The tensor aliases values, so the caller must keep it alive and unmodified until after evaluate().

Definition at line 138 of file HyPERModel.h.

                                                  {
    using namespace asg::msgUserCode;
    static_assert(std::is_same_v<T, float> || std::is_same_v<T, int64_t>,
                  "HyPER ONNX inputs must be float or int64_t");
    const auto it = m_inputIndex.find(node);
    if (it == m_inputIndex.end()) {
      ANA_MSG_ERROR("HyPERModel: unknown input node '" << node << "'");
      return;
    }
    BoundInput& bound = m_boundInputs[it->second];
    bound.data = &values;
    bound.shape = shape;
    bound.set = true;
  }

setTopology()

void EventReco::HyPERModel::setTopology ( HyPERTopology topology )

deleteinherited

shapeToString()

std::string EventReco::HyPERModel::shapeToString ( const std::vector< int64_t > & shape )

inlinestaticprivateinherited

Definition at line 303 of file HyPERModel.h.

                                                                  {
    std::string row = "(";
    for (const int64_t dim : shape) row += std::to_string(dim) + ", ";
    return row + ")";
  }

Member Data Documentation

m_boundInputs

std::vector<BoundInput> EventReco::HyPERModel::m_boundInputs {}

privateinherited

Definition at line 313 of file HyPERModel.h.

{};

m_inputIndex

std::map<std::string, std::size_t> EventReco::HyPERModel::m_inputIndex {}

privateinherited

Definition at line 312 of file HyPERModel.h.

{};

m_outputIndex

std::map<std::string, std::size_t> EventReco::HyPERModel::m_outputIndex {}

privateinherited

Definition at line 316 of file HyPERModel.h.

{};

m_outputNodes

std::vector<HyPEROutputNode> EventReco::HyPERModel::m_outputNodes {}

privateinherited

Definition at line 315 of file HyPERModel.h.

{};

m_outputsFloat

std::vector<std::vector<float> > EventReco::HyPERModel::m_outputsFloat {}

privateinherited

Definition at line 317 of file HyPERModel.h.

{};

m_outputsInt64

std::vector<std::vector<int64_t> > EventReco::HyPERModel::m_outputsInt64 {}

privateinherited

Definition at line 318 of file HyPERModel.h.

{};

m_toolTrainedOnEven

const AthOnnx::IOnnxRuntimeInferenceTool* EventReco::HyPERModel::m_toolTrainedOnEven {nullptr}

privateinherited

Definition at line 309 of file HyPERModel.h.

{nullptr};

m_toolTrainedOnOdd

const AthOnnx::IOnnxRuntimeInferenceTool* EventReco::HyPERModel::m_toolTrainedOnOdd {nullptr}

privateinherited

Definition at line 310 of file HyPERModel.h.

{nullptr};

m_topology

HyPERTopology EventReco::HyPERModel::m_topology {HyPERTopology::NotSelected}

protectedinherited

Definition at line 281 of file HyPERModel.h.

{HyPERTopology::NotSelected};

s_edgeIndexName

const char* EventReco::HyPERModel::s_edgeIndexName = "edge_index"

staticconstexprprivateinherited

Input nodes whose shapes carry the graph's dynamic dimensions.

These are named identically in every HyPER topology.

Definition at line 286 of file HyPERModel.h.

s_hyperEdgeIndexName

const char* EventReco::HyPERModel::s_hyperEdgeIndexName = "edge_index_h"

staticconstexprprivateinherited

Definition at line 287 of file HyPERModel.h.

---

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

• HyPERTtbarDiLeptonModel.h