ElectronDNNCalculator Class Reference

Used by AsgElectronSelectorTool to calculate the score of a python trained DNN using lwtnn as interface to do electron ID. More...

#include <ElectronDNNCalculator.h>

Inheritance diagram for ElectronDNNCalculator:

Collaboration diagram for ElectronDNNCalculator:

Public Member Functions
	ElectronDNNCalculator (AsgElectronSelectorTool *owner, const std::string &modelFileName, const std::string &quantileFileName, const std::vector< std::string > &variablesName)
	Constructor of the class.
	~ElectronDNNCalculator ()
	Standard destructor.
Eigen::Matrix< float, -1, 1 >	calculate (const std::vector< double > &) const
	Get the prediction of the DNN model.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
double	transformInput (const std::vector< double > &quantiles, double value) const
	transform the input variables according to a given QuantileTransformer.
int	readQuantileTransformer (TTree *tree)
	read the bins and values of the QuantileTransformer to transform the input variables.

Private Attributes
std::unique_ptr< lwt::generic::FastGraph< float > >	m_graph = 0
	DNN interface via lwtnn.
std::vector< std::vector< double > >	m_quantiles
	Quantile values for each variable that needs to be transformed with the QuantileTransformer.
std::vector< double >	m_references
	Reference values for the QuantileTransformer. Basically just equidistant bins between 0 and 1.
std::vector< std::string >	m_variables
	Model variables.
uint	m_var_size
std::function< MsgStream &()>	m_msg
	the message stream we use

Detailed Description

Used by AsgElectronSelectorTool to calculate the score of a python trained DNN using lwtnn as interface to do electron ID.

Also applies a transformation to the input variables based on a QuantileTransformer.

Author

Lukas Ehrke

Definition at line 23 of file ElectronDNNCalculator.h.

Constructor & Destructor Documentation

ElectronDNNCalculator()

ElectronDNNCalculator::ElectronDNNCalculator	(	AsgElectronSelectorTool *	owner,
		const std::string &	modelFileName,
		const std::string &	quantileFileName,
		const std::vector< std::string > &	variablesName )

Constructor of the class.

Definition at line 23 of file ElectronDNNCalculator.cxx.

                                                                                    :
                                            asg::AsgMessagingForward(owner),
                                            m_quantiles(variables.size()),
                                            m_variables(variables),
                                            m_var_size(variables.size())
{
 
  ATH_MSG_INFO("Initializing ElectronDNNCalculator...");
  for (const auto& var : m_variables) {
    ATH_MSG_DEBUG("VARIABLE: " << var );
  }
  if (modelFileName.empty()){
    throw std::runtime_error("No file found at '" + modelFileName + "'");
  }
 
  // Make an input file object
  std::ifstream inputFile;
 
  // Open your trained model
  ATH_MSG_INFO("Loading model: " << modelFileName.c_str());
 
  // Create input order for the NN, the data needs to be passed in this exact order
  lwt::InputOrder order;
  order.scalar.emplace_back("node_0", m_variables );
 
  // create the model
  inputFile.open(modelFileName);
  auto parsedGraph = lwt::parse_json_graph(inputFile);
 
  m_graph = std::make_unique<lwt::generic::FastGraph<float>>(parsedGraph, order);
 
  if (quantileFileName.empty()){
    throw std::runtime_error("No file found at '" + quantileFileName + "'");
  }
 
  // Open quantiletransformer file
  ATH_MSG_INFO("Loading QuantileTransformer " << quantileFileName);
  std::unique_ptr<TFile> qtfile(TFile::Open(quantileFileName.data()));
  if (readQuantileTransformer((TTree*)qtfile->Get("tree")) == 0){
    throw std::runtime_error("Could not load all variables for the QuantileTransformer");
 
  }
}

~ElectronDNNCalculator()

ElectronDNNCalculator::~ElectronDNNCalculator ( )

inline

Standard destructor.

Definition at line 33 of file ElectronDNNCalculator.h.

{};

Member Function Documentation

calculate()

Eigen::Matrix< float, -1, 1 > ElectronDNNCalculator::calculate

(

const std::vector< double > &

variableValues

)

const

Get the prediction of the DNN model.

Definition at line 71 of file ElectronDNNCalculator.cxx.

{
 
  if(variableValues.size() != m_var_size)
    throw std::runtime_error("Passed vector of variables has wrong size");
 
  // Create the input for the model
  Eigen::VectorXf inputVector(m_variables.size());
 
  // This has to be in the same order as the InputOrder was defined
  for(uint i = 0; i < m_var_size; ++i){
    inputVector(i) = transformInput(m_quantiles.at(i), variableValues.at(i));
  }
 
  std::vector<Eigen::VectorXf> inp;
  inp.emplace_back(std::move(inputVector));
 
  auto output = m_graph->compute(inp);
  return output;
}

msg() [1/2]

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

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 24 of file AsgMessagingForward.cxx.

  {
    return m_msg();
  }

msg() [2/2]

MsgStream & asg::AsgMessagingForward::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 29 of file AsgMessagingForward.cxx.

  {
    MsgStream& msg = m_msg ();
    msg << lvl;
    return msg;
  }

msgLvl()

bool asg::AsgMessagingForward::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 11 of file AsgMessagingForward.cxx.

  {
    MsgStream& msg = m_msg();
    if (msg.level() <= lvl)
    {
      msg << lvl;
      return true;
    } else
    {
      return false;
    }
  }

readQuantileTransformer()

int ElectronDNNCalculator::readQuantileTransformer ( TTree * tree )

private

read the bins and values of the QuantileTransformer to transform the input variables.

Definition at line 128 of file ElectronDNNCalculator.cxx.

{
  int sc(1);
  // the reference bins to which the variables will be transformed to
  double references;
  sc = tree->SetBranchAddress("references", &references) == -5 ? 0 : 1;
 
  std::map<std::string, double> readVars;
  for ( const auto& var : m_variables ){
    sc = tree->SetBranchAddress(TString(var), &readVars[var]) == -5 ? 0 : 1;
  }
 
  for (int ientry = 0; ientry < tree->GetEntries(); ientry++){
    tree->GetEntry(ientry);
    m_references.push_back(references);
    for(uint ivar = 0; ivar < m_var_size; ++ivar){
      m_quantiles.at(ivar).push_back(readVars[m_variables.at(ivar)]);
    }
  }
  return sc;
}

transformInput()

double ElectronDNNCalculator::transformInput ( const std::vector< double > & quantiles, double value ) const

private

transform the input variables according to a given QuantileTransformer.

Definition at line 96 of file ElectronDNNCalculator.cxx.

{
  int size = quantiles.size();
 
  // if given value is outside of range of the given quantiles return min (0) or max (1) of references
  if (value <= quantiles[0]) return m_references[0];
  if (value >= quantiles[size-1]) return m_references[size-1];
 
  // find the bin where the value is smaller than the next bin (going from low bins to large bins)
  auto lowBound = std::lower_bound(quantiles.begin(), quantiles.end(), value);
  int lowBin = lowBound - quantiles.begin() - 1;
 
  // get x and y values on left and right side from value while going up
  double xLup = quantiles[lowBin], yLup = m_references[lowBin], xRup = quantiles[lowBin+1], yRup = m_references[lowBin+1];
 
  // find the bin where the value is larger than the next bin (going from large bins to low bins)
  auto upperBound = std::upper_bound(quantiles.begin(), quantiles.end(), value);
  int upperBin = upperBound - quantiles.begin();
 
  // get x and y values on left and right side from value while going down
  double xRdown = quantiles[upperBin], yRdown = m_references[upperBin], xLdown = quantiles[upperBin-1], yLdown = m_references[upperBin-1];
 
  // calculate the gradients
  double dydxup = ( yRup - yLup ) / ( xRup - xLup );
  double dydxdown = ( yRdown - yLdown ) / ( xRdown - xLdown );
 
  // average linear interpolation of up and down case
  return 0.5 * ((yLup + dydxup * (value - xLup)) + (yLdown + dydxdown * (value - xLdown)));
}

Member Data Documentation

m_graph

std::unique_ptr<lwt::generic::FastGraph<float> > ElectronDNNCalculator::m_graph = 0

private

DNN interface via lwtnn.

Definition at line 45 of file ElectronDNNCalculator.h.

m_msg

std::function<MsgStream& ()> asg::AsgMessagingForward::m_msg

privateinherited

the message stream we use

This used to be a simple pointer to the MsgStream itself, but in AthenaMT the actual object used is local to the thread. So instead of pointing to it directly we are now using a function to look it up, which will get the thread-local object.

Definition at line 77 of file AsgMessagingForward.h.

m_quantiles

std::vector<std::vector<double> > ElectronDNNCalculator::m_quantiles

private

Quantile values for each variable that needs to be transformed with the QuantileTransformer.

Definition at line 48 of file ElectronDNNCalculator.h.

m_references

std::vector<double> ElectronDNNCalculator::m_references

private

Reference values for the QuantileTransformer. Basically just equidistant bins between 0 and 1.

Definition at line 50 of file ElectronDNNCalculator.h.

m_var_size

uint ElectronDNNCalculator::m_var_size

private

Definition at line 53 of file ElectronDNNCalculator.h.

m_variables

std::vector<std::string> ElectronDNNCalculator::m_variables

private

Model variables.

Definition at line 52 of file ElectronDNNCalculator.h.

---

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

• ElectronDNNCalculator.h
• ElectronDNNCalculator.cxx