ONNXExpert Class Reference

Expert for the ONNX MVA method. More...

#include <ONNX.h>

Inheritance diagram for ONNXExpert:

Collaboration diagram for ONNXExpert:

Public Member Functions
virtual void	load (Weightfile &weightfile) override
	Load the expert from a Weightfile.
virtual std::vector< float >	apply (Dataset &testData) const override
	Apply this expert onto a dataset.
virtual std::vector< std::vector< float > >	applyMulticlass (Dataset &test_data) const override
	Apply this expert onto a dataset and return multiple outputs.

Protected Attributes
GeneralOptions	m_general_options
	General options loaded from the weightfile.

Private Member Functions
void	configureInputOutputNames ()
	Set up input and output names and perform consistency checks.
void	configureOutputValueIndex ()
	Configure index of the value to be used for the configured output tensor.

Private Attributes
std::unique_ptr< ONNX::Session >	m_session
	The ONNX inference session wrapper.
ONNXOptions	m_specific_options
	ONNX specific options loaded from weightfile.
std::string	m_inputName
	Name of the input tensor (will be determined automatically)
std::string	m_outputName
	Name of the output tensor (will either be determined automatically or loaded from specific options)
int	m_outputValueIndex
	Index of the output value to pick in non-multiclass mode.

Detailed Description

Expert for the ONNX MVA method.

Definition at line 446 of file ONNX.h.

Member Function Documentation

apply()

std::vector< float > apply ( Dataset & testData ) const

overridevirtual

Apply this expert onto a dataset.

Parameters

testData

dataset

Implements Expert.

Definition at line 168 of file ONNX.cc.

{
  const auto nFeatures = testData.getNumberOfFeatures();
  const auto nEvents = testData.getNumberOfEvents();
  const int nOutputs = (m_outputValueIndex == 1) ? 2 : 1;
  auto input = Tensor<float>::make_shared({1, nFeatures});
  auto output = Tensor<float>::make_shared({1, nOutputs});
  std::vector<float> result;
  result.reserve(nEvents);
  for (unsigned int iEvent = 0; iEvent < nEvents; ++iEvent) {
    testData.loadEvent(iEvent);
    input->setValues(testData.m_input);
    m_session->run({{m_inputName, input}}, {{m_outputName, output}});
    result.push_back(output->at(m_outputValueIndex));
  }
  return result;
}

applyMulticlass()

std::vector< std::vector< float > > applyMulticlass ( Dataset & test_data ) const

overridevirtual

Apply this expert onto a dataset and return multiple outputs.

Parameters

test_data

dataset

Reimplemented from Expert.

Definition at line 186 of file ONNX.cc.

{
  const unsigned int nClasses = m_general_options.m_nClasses;
  const auto nFeatures = testData.getNumberOfFeatures();
  const auto nEvents = testData.getNumberOfEvents();
  auto input = Tensor<float>::make_shared({1, nFeatures});
  auto output = Tensor<float>::make_shared({1, nClasses});
  std::vector<std::vector<float>> result(nEvents, std::vector<float>(nClasses));
  for (unsigned int iEvent = 0; iEvent < nEvents; ++iEvent) {
    testData.loadEvent(iEvent);
    input->setValues(testData.m_input);
    m_session->run({{m_inputName, input}}, {{m_outputName, output}});
    for (unsigned int iClass = 0; iClass < nClasses; ++iClass) {
      result[iEvent][iClass] = output->at(iClass);
    }
  }
  return result;
}

configureInputOutputNames()

void configureInputOutputNames ( )

private

Set up input and output names and perform consistency checks.

Definition at line 89 of file ONNX.cc.

{
  const auto& inputNames = m_session->getOrtSession().GetInputNames();
  const auto& outputNames = m_session->getOrtSession().GetOutputNames();
 
  // Check if we have a single input model and set the input name to that
  if (inputNames.size() != 1) {
    std::stringstream msg;
    msg << "Model has multiple inputs: ";
    for (auto name : inputNames)
      msg << "\"" << name << "\" ";
    msg << "- only single-input models are supported.";
    B2FATAL(msg.str());
  }
  m_inputName = inputNames[0];
 
  m_outputName = m_specific_options.m_outputName;
 
  // For single-output models we just take the name of that single output
  if (outputNames.size() == 1) {
    if (!m_outputName.empty() && m_outputName != outputNames[0]) {
      B2INFO("Output name of the model is "
             << outputNames[0]
             << " - will use that despite the configured name being \""
             << m_outputName << "\"");
    }
    m_outputName = outputNames[0];
    return;
  }
 
  // Otherwise we have a multiple-output model and need to check if the
  // configured output name, or the fallback value "output", exists
  if (m_outputName.empty()) {
    m_outputName = "output";
  }
  auto outputFound = std::find(outputNames.begin(), outputNames.end(),
                               m_outputName) != outputNames.end();
  if (!outputFound) {
    std::stringstream msg;
    msg << "No output named \"" << m_outputName << "\" found. Instead got ";
    for (auto name : outputNames)
      msg << "\"" << name << "\" ";
    msg << "- either change your model to contain one named \"" << m_outputName
        << "\" or set `m_outputName` in the specific options to one of the available names.";
    B2FATAL(msg.str());
  }
}

configureOutputValueIndex()

void configureOutputValueIndex ( )

private

Configure index of the value to be used for the configured output tensor.

Will be 0 in case of a single element (binary classifier with single output or regression) and 1 in case of 2 elements (binary classifier with 2 outputs). For more than 2 elements one has to call applyMultiClass.

Definition at line 137 of file ONNX.cc.

{
  int tensorIndex = 0;
  for (auto name : m_session->getOrtSession().GetOutputNames()) {
    if (name == m_outputName)
      break;
    ++tensorIndex;
  }
  auto typeInfo = m_session->getOrtSession().GetOutputTypeInfo(tensorIndex);
  auto shape = typeInfo.GetTensorTypeAndShapeInfo().GetShape();
  if (shape.back() == 2) {
    // We have 2 output values
    // -> configure to use signal_class index (default 1) in non-multiclass mode
    m_outputValueIndex = m_general_options.m_signal_class;
  } else {
    // otherwise use the default of 0
    m_outputValueIndex = 0;
  }
}

load()

void load ( Weightfile & weightfile )

overridevirtual

Load the expert from a Weightfile.

Parameters

weightfile

containing all information necessary to build the expert

Implements Expert.

Definition at line 157 of file ONNX.cc.

{
  std::string onnxModelFileName = weightfile.generateFileName();
  weightfile.getFile("ONNX_Modelfile", onnxModelFileName);
  weightfile.getOptions(m_general_options);
  weightfile.getOptions(m_specific_options);
  m_session = std::make_unique<Session>(onnxModelFileName.c_str());
  configureInputOutputNames();
  configureOutputValueIndex();
}

Member Data Documentation

m_general_options

GeneralOptions m_general_options

protectedinherited

General options loaded from the weightfile.

Definition at line 70 of file Expert.h.

m_inputName

std::string m_inputName

private

Name of the input tensor (will be determined automatically)

Definition at line 494 of file ONNX.h.

m_outputName

std::string m_outputName

private

Name of the output tensor (will either be determined automatically or loaded from specific options)

Definition at line 500 of file ONNX.h.

m_outputValueIndex

int m_outputValueIndex

private

Index of the output value to pick in non-multiclass mode.

Definition at line 505 of file ONNX.h.

m_session

std::unique_ptr<ONNX::Session> m_session

private

The ONNX inference session wrapper.

Definition at line 484 of file ONNX.h.

m_specific_options

ONNXOptions m_specific_options

private

ONNX specific options loaded from weightfile.

Definition at line 489 of file ONNX.h.

---

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

• mva/methods/include/ONNX.h
• mva/methods/src/ONNX.cc