EventReco::HyPERTtbarAllHadronicModel Class Reference

This class is in charge of loading the correct HyPER model based on the Ttbar all hadronic topology. More...

#include <HyPERTtbarAllHadronicModel.h>

Inheritance diagram for EventReco::HyPERTtbarAllHadronicModel:

Collaboration diagram for EventReco::HyPERTtbarAllHadronicModel:

Public Member Functions
	HyPERTtbarAllHadronicModel (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 all hadronic topology.

Definition at line 20 of file HyPERTtbarAllHadronicModel.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

HyPERTtbarAllHadronicModel()

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

inline

Definition at line 22 of file HyPERTtbarAllHadronicModel.h.

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

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::HyPERTtbarAllHadronicModel::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 30 of file HyPERTtbarAllHadronicModel.h.

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

getModelOutputs()

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

inlineoverridevirtual

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

Implements EventReco::HyPERModel.

Definition at line 41 of file HyPERTtbarAllHadronicModel.h.

                                                              {
    return std::vector<HyPEROutputNode>{
        {"sigmoid_1", true, HyPEROutputDim::HyperEdges, true},
        {"edge_index_h_batch", false, HyPEROutputDim::HyperEdges, false},
        {"sigmoid", true, HyPEROutputDim::Edges, true}};
  }

getOutputNames()

std::vector< std::string > EventReco::HyPERTtbarAllHadronicModel::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 48 of file HyPERTtbarAllHadronicModel.h.

                                                       {
    return std::vector<std::string>{"sigmoid_1", "sigmoid"};
  }

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:

• HyPERTtbarAllHadronicModel.h