MVAExpert Class Reference

Class to interact with the MVA package, based on class with same name in CDC package. More...

#include <MVAExpert.h>

Public Member Functions
	MVAExpert (const std::string &identifier, std::vector< Named< float * > > namedVariables)
	Construct the Expert with the specified weight folder and the name of the training that was used in the teacher run.
void	initialize ()
	Initialise the mva method.
void	beginRun ()
	Update the mva method to the new run.
std::unique_ptr< MVA::Weightfile >	getWeightFile ()
	Resolves the source of the weight file and unpacks it.
float	predict ()
	Evaluate the MVA method and return the MVAOutput.

Private Attributes
std::vector< Named< float * > >	m_allNamedVariables
	References to the named values from the source variable set.
std::vector< Named< float * > >	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.
std::string	m_identifier
	DB identifier of the expert or file name.

Detailed Description

Class to interact with the MVA package, based on class with same name in CDC package.

Definition at line 33 of file MVAExpert.h.

Constructor & Destructor Documentation

MVAExpert()

MVAExpert	(	const std::string &	identifier,
		std::vector< Named< float * > >	namedVariables
	)

Construct the Expert with the specified weight folder and the name of the training that was used in the teacher run.

Parameters

identifier	A database identifier or local file name.
namedVariables	The names and pointers to the variables to be fed to the mva method

Definition at line 20 of file MVAExpert.cc.

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

Member Function Documentation

beginRun()

void beginRun

(

)

Update the mva method to the new run.

Definition at line 38 of file MVAExpert.cc.

{
  std::unique_ptr<MVA::Weightfile> weightfile = getWeightFile();
  if (weightfile) {
    // FastBDT_version refers to the weightfile version, only FastBDT_VERSION_MAJOR >= 5 can handle FastBDT_version==2
    if (weightfile->getElement<std::string>("method") == "FastBDT" and
        (weightfile->getElement<int>("FastBDT_version") == 1 or
         weightfile->getElement<int>("FastBDT_version") == 2)) {
 
      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.");
      m_selectedNamedVariables = m_allNamedVariables;
    }
 
    std::map<std::string, MVA::AbstractInterface*> supportedInterfaces =
      MVA::AbstractInterface::getSupportedInterfaces();
    MVA::GeneralOptions generalOptions;
    weightfile->getOptions(generalOptions);
    m_expert = supportedInterfaces[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>(generalOptions, std::move(dummy), 0);
  } else {
    B2ERROR("Could not find weight file for identifier " << m_identifier);
  }
}

getWeightFile()

std::unique_ptr< MVA::Weightfile > getWeightFile

(

)

Resolves the source of the weight file and unpacks it.

Definition at line 87 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

(

)

Initialise the mva method.

Definition at line 27 of file MVAExpert.cc.

{
  MVA::AbstractInterface::initSupportedInterfaces();
  using boost::algorithm::ends_with;
  if (not m_weightfileRepresentation and
      not(ends_with(m_identifier, ".root") or ends_with(m_identifier, ".xml"))) {
    using DBWeightFileRepresentation = DBObjPtr<DatabaseRepresentationOfWeightfile>;
    m_weightfileRepresentation = std::make_unique<DBWeightFileRepresentation>(m_identifier);
  }
}

predict()

float predict

(

)

Evaluate the MVA method and return the MVAOutput.

Definition at line 98 of file MVAExpert.cc.

{
  if (not m_expert) {
    B2ERROR("MVA Expert is not loaded! I will return 0");
    return 0;
  }
 
  // 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].getValue());
  }
  return m_expert->apply(*m_dataset)[0];
}

Member Data Documentation

m_allNamedVariables

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

private

References to the named values from the source variable set.

Definition at line 57 of file MVAExpert.h.

m_dataset

std::unique_ptr<MVA::Dataset> m_dataset

private

Pointer to the current dataset.

Definition at line 69 of file MVAExpert.h.

m_expert

std::unique_ptr<MVA::Expert> m_expert

private

Pointer to the current MVA Expert.

Definition at line 66 of file MVAExpert.h.

m_identifier

std::string m_identifier

private

DB identifier of the expert or file name.

Definition at line 72 of file MVAExpert.h.

m_selectedNamedVariables

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

private

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

Definition at line 60 of file MVAExpert.h.

m_weightfileRepresentation

std::unique_ptr<DBObjPtr<DatabaseRepresentationOfWeightfile> > m_weightfileRepresentation

private

Database pointer to the Database representation of the weightfile.

Definition at line 63 of file MVAExpert.h.

---

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

• tracking/trackFindingVXD/mva/include/MVAExpert.h
• tracking/trackFindingVXD/mva/src/MVAExpert.cc