MVAExpert::Impl Class Reference

Implementation of the class to interact with the MVA package. More...

Public Member Functions
	Impl (const std::string &identifier, std::vector< Named< Float_t * > > namedVariables)
	constructor
void	initialize ()
	Signal the beginning of the event processing.
void	beginRun ()
	Called once before a new run begins.
std::unique_ptr< MVA::Weightfile >	getWeightFile ()
	Get the weight file.
double	predict ()
	Get the MVA prediction.
std::vector< float >	predict (float *, int, int)
	Get predictions for several inputs.
std::vector< std::string >	getVariableNames ()
	Get selected variable names.

Private Attributes
std::vector< Named< Float_t * > >	m_allNamedVariables
	References to the all named values from the source variable set.
std::vector< Named< Float_t * > >	m_selectedNamedVariables
	References to the selected named values from the source variable set.
std::unique_ptr< DBObjPtr< DatabaseRepresentationOfWeightfile > >	m_weightfileRepresentation
	Database pointer to the Database representation of the weightfile.
std::unique_ptr< MVA::Expert >	m_expert
	Pointer to the current MVA Expert.
std::unique_ptr< MVA::Dataset >	m_dataset
	Pointer to the current dataset.
MVA::GeneralOptions	m_generalOptions
	General options.
std::string	m_identifier
	DB identifier of the expert or file name.

Detailed Description

Implementation of the class to interact with the MVA package.

Definition at line 30 of file MVAExpert.cc.

Constructor & Destructor Documentation

Impl()

Impl	(	const std::string &	identifier,
		std::vector< Named< Float_t * > >	namedVariables )

constructor

Definition at line 77 of file MVAExpert.cc.

  : m_allNamedVariables(std::move(namedVariables))
  , m_identifier(identifier)
{
}

Member Function Documentation

beginRun()

void beginRun

(

)

Called once before a new run begins.

Definition at line 97 of file MVAExpert.cc.

{
  std::unique_ptr<MVA::Weightfile> weightfile = getWeightFile();
  if (weightfile) {
    if ((weightfile->getElement<std::string>("method") == "FastBDT" and
         (weightfile->getElement<int>("FastBDT_version") == 1 or
          weightfile->getElement<int>("FastBDT_version") == 2)) or
        (weightfile->getElement<std::string>("method") == "Python")) {
 
      int nExpectedVars = weightfile->getElement<int>("number_feature_variables");
 
      m_selectedNamedVariables.clear();
      for (int iVar = 0; iVar < nExpectedVars; ++iVar) {
        std::string variableElementName = "variable" + std::to_string(iVar);
        std::string expectedName = weightfile->getElement<std::string>(variableElementName);
        auto itNamedVariable = std::find_if(m_allNamedVariables.begin(),
                                            m_allNamedVariables.end(),
        [expectedName](const Named<Float_t*>& namedVariable) {
          return namedVariable.getName() == expectedName;
        });
 
        if (itNamedVariable == m_allNamedVariables.end()) {
          B2ERROR("Variable name " << iVar << " mismatch for FastBDT. " <<
                  "Could not find expected variable '" << expectedName << "'");
        }
        m_selectedNamedVariables.push_back(*itNamedVariable);
      }
      B2ASSERT("Number of variables mismatch", nExpectedVars == static_cast<int>(m_selectedNamedVariables.size()));
    } else {
      B2WARNING("Unpacked new kind of classifier. Consider to extend the feature variable check. Identifier name: " << m_identifier
                << "; method name: " << weightfile->getElement<std::string>("method"));
      m_selectedNamedVariables = m_allNamedVariables;
    }
 
    std::map<std::string, MVA::AbstractInterface*> supportedInterfaces =
      MVA::AbstractInterface::getSupportedInterfaces();
    weightfile->getOptions(m_generalOptions);
    m_expert = supportedInterfaces[m_generalOptions.m_method]->getExpert();
    m_expert->load(*weightfile);
 
    std::vector<float> dummy;
    dummy.resize(m_selectedNamedVariables.size(), 0);
    m_dataset = std::make_unique<MVA::SingleDataset>(m_generalOptions, std::move(dummy), 0);
  } else {
    B2ERROR("Could not find weight file for identifier " << m_identifier);
  }
}

getVariableNames()

std::vector< std::string > getVariableNames

(

)

Get selected variable names.

Definition at line 186 of file MVAExpert.cc.

{
  std::vector<std::string> out(m_selectedNamedVariables.size());
  for (size_t iName = 0; iName < m_selectedNamedVariables.size(); iName += 1) {
    out[iName] = m_selectedNamedVariables[iName].getName();
  }
  return out;
}

getWeightFile()

std::unique_ptr< MVA::Weightfile > getWeightFile

(

)

Get the weight file.

Definition at line 145 of file MVAExpert.cc.

{
  if (m_weightfileRepresentation) {
    std::stringstream ss((*m_weightfileRepresentation)->m_data);
    return std::make_unique<MVA::Weightfile>(MVA::Weightfile::loadFromStream(ss));
  } else {
    std::string weightFilePath = FileSystem::findFile(m_identifier);
    return std::make_unique<MVA::Weightfile>(MVA::Weightfile::loadFromFile(weightFilePath));
  }
}

initialize()

void initialize

(

)

Signal the beginning of the event processing.

Definition at line 84 of file MVAExpert.cc.

{
  MVA::AbstractInterface::initSupportedInterfaces();
  if (not m_weightfileRepresentation and
      not(m_identifier.ends_with(".root") or m_identifier.ends_with(".xml"))) {
    using DBWeightFileRepresentation = DBObjPtr<DatabaseRepresentationOfWeightfile>;
    m_weightfileRepresentation = std::make_unique<DBWeightFileRepresentation>(m_identifier);
  }
  if ((not m_weightfileRepresentation) or (not m_weightfileRepresentation->isValid())) {
    B2FATAL("No weight file could be loaded in tracking/trackingUtilities/mva/MVAExpert.");
  }
}

predict() [1/2]

double predict

(

)

Get the MVA prediction.

Definition at line 156 of file MVAExpert.cc.

{
  if (not m_expert) {
    B2ERROR("MVA Expert is not loaded! I will return 0");
    return NAN;
  }
 
  // Transfer the extracted values to the data set were the expert can find them
  for (unsigned int i = 0; i < m_selectedNamedVariables.size(); ++i) {
    m_dataset->m_input[i] = *m_selectedNamedVariables[i];
  }
  return m_expert->apply(*m_dataset)[0];
}

predict() [2/2]

std::vector< float > predict	(	float *	test_data,
		int	nFeature,
		int	nRows )

Get predictions for several inputs.

Definition at line 170 of file MVAExpert.cc.

{
  std::vector<std::vector<float>> spectators;
  std::vector<std::vector <float> > data;
  data.resize(nRows);
  for (int iRow = 0; iRow < nRows; iRow += 1) {
    data[iRow].resize(nFeature);
    for (int iFeature = 0; iFeature < nFeature; iFeature += 1) {
      data[iRow][iFeature] = test_data[nFeature * iRow + iFeature];
    }
  }
 
  MVA::MultiDataset dataSet(m_generalOptions, data, spectators);
  return m_expert->apply(dataSet);
}

Member Data Documentation

m_allNamedVariables

std::vector<Named<Float_t*> > m_allNamedVariables

private

References to the all named values from the source variable set.

Definition at line 42 of file MVAExpert.cc.

m_dataset

std::unique_ptr<MVA::Dataset> m_dataset

private

Pointer to the current dataset.

Definition at line 54 of file MVAExpert.cc.

m_expert

std::unique_ptr<MVA::Expert> m_expert

private

Pointer to the current MVA Expert.

Definition at line 51 of file MVAExpert.cc.

m_generalOptions

MVA::GeneralOptions m_generalOptions

private

General options.

Definition at line 57 of file MVAExpert.cc.

m_identifier

std::string m_identifier

private

DB identifier of the expert or file name.

Definition at line 60 of file MVAExpert.cc.

m_selectedNamedVariables

std::vector<Named<Float_t*> > m_selectedNamedVariables

private

References to the selected named values from the source variable set.

Definition at line 45 of file MVAExpert.cc.

m_weightfileRepresentation

std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile> > m_weightfileRepresentation

private

Database pointer to the Database representation of the weightfile.

Definition at line 48 of file MVAExpert.cc.

---

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

• tracking/trackingUtilities/mva/src/MVAExpert.cc