#include <TMVAEvaluator.h>

Public Member Functions
float	evaluate (const std::map< std::string, float > &inputs, bool useSpectators=false) const

float	evaluateGBRForest (const std::map< std::string, float > &inputs) const

float	evaluateTMVA (const std::map< std::string, float > &inputs, bool useSpectators) const

void	initialize (const std::string &options, const std::string &method, const std::string &weightFile, const std::vector< std::string > &variables, const std::vector< std::string > &spectators, bool useGBRForest=false, bool useAdaBoost=false)

void	initializeGBRForest (const GBRForest *gbrForest, const std::vector< std::string > &variables, const std::vector< std::string > &spectators, bool useAdaBoost=false)

void	initializeGBRForest (const edm::EventSetup &iSetup, const std::string &label, const std::vector< std::string > &variables, const std::vector< std::string > &spectators, bool useAdaBoost=false)

	TMVAEvaluator ()

Private Attributes
std::mutex	m_mutex

std::shared_ptr< const GBRForest >	mGBRForest

bool	mIsInitialized

std::string	mMethod

std::unique_ptr< TMVA::Reader >	mReader

std::map< std::string, std::pair< size_t, float > >	mSpectators

bool	mUseAdaBoost

bool	mUsingGBRForest

std::map< std::string, std::pair< size_t, float > >	mVariables

Detailed Description

Definition at line 16 of file TMVAEvaluator.h.

Constructor & Destructor Documentation

TMVAEvaluator::TMVAEvaluator ( )

Definition at line 10 of file TMVAEvaluator.cc.

                              :
   mIsInitialized(false), mUsingGBRForest(false), mUseAdaBoost(false)
 {
 }

Member Function Documentation

float TMVAEvaluator::evaluate	(	const std::map< std::string, float > &	inputs,
		bool	useSpectators = `false`
	)		const

Definition at line 155 of file TMVAEvaluator.cc.

References evaluateGBRForest(), evaluateTMVA(), mIsInitialized, mSpectators, mUsingGBRForest, mVariables, and relativeConstraints::value.

 {
   // default value
   float value = -99.;
 
   if(!mIsInitialized)
   {
     edm::LogError("InitializationError") << "TMVAEvaluator not properly initialized.";
     return value;
   }
 
   if( useSpectators && inputs.size() < ( mVariables.size() + mSpectators.size() ) )
   {
     edm::LogError("MissingInputs") << "Too few inputs provided (" << inputs.size() << " provided but " << mVariables.size() << " input and " << mSpectators.size() << " spectator variables expected).";
     return value;
   }
   else if( inputs.size() < mVariables.size() )
   {
     edm::LogError("MissingInputVariable(s)") << "Too few input variables provided (" << inputs.size() << " provided but " << mVariables.size() << " expected).";
     return value;
   }
 
   if (mUsingGBRForest)
   {
     if(useSpectators)
       edm::LogWarning("UnsupportedFunctionality") << "Use of spectator variables with GBRForest is not supported. Spectator variables will be ignored.";
     value = evaluateGBRForest(inputs);
   }
   else
     value = evaluateTMVA(inputs, useSpectators);
 
   return value;
 }

float TMVAEvaluator::evaluateGBRForest ( const std::map< std::string, float > & inputs ) const

Definition at line 130 of file TMVAEvaluator.cc.

References mGBRForest, mUseAdaBoost, mVariables, and relativeConstraints::value.

Referenced by evaluate().

 {
   // default value
   float value = -99.;
 
   std::unique_ptr<float[]> vars(new float[mVariables.size()]); // allocate n floats
 
   // set the input variable values
   for(auto it = mVariables.begin(); it!=mVariables.end(); ++it)
   {
     if (inputs.count(it->first)>0)
       vars[it->second.first] = inputs.at(it->first);
     else
       edm::LogError("MissingInputVariable") << "Input variable " << it->first << " is missing from the list of inputs. The returned discriminator value might not be sensible.";
   }
 
   // evaluate the MVA
   if (mUseAdaBoost)
     value = mGBRForest->GetAdaBoostClassifier(vars.get());
   else
     value = mGBRForest->GetGradBoostClassifier(vars.get());
 
   return value;
 }

float TMVAEvaluator::evaluateTMVA	(	const std::map< std::string, float > &	inputs,
		bool	useSpectators
	)		const

Definition at line 93 of file TMVAEvaluator.cc.

References CommonMethods::lock(), m_mutex, mMethod, mReader, mSpectators, mVariables, and relativeConstraints::value.

Referenced by evaluate().

 {
   // default value
   float value = -99.;
 
   // TMVA::Reader is not thread safe
   std::lock_guard<std::mutex> lock(m_mutex);
 
   // set the input variable values
   for(auto it = mVariables.begin(); it!=mVariables.end(); ++it)
   {
     if (inputs.count(it->first)>0)
       it->second.second = inputs.at(it->first);
     else
       edm::LogError("MissingInputVariable") << "Input variable " << it->first << " is missing from the list of inputs. The returned discriminator value might not be sensible.";
   }
 
   // if using spectator variables
   if(useSpectators)
   {
     // set the spectator variable values
     for(auto it = mSpectators.begin(); it!=mSpectators.end(); ++it)
     {
       if (inputs.count(it->first)>0)
         it->second.second = inputs.at(it->first);
       else
         edm::LogError("MissingSpectatorVariable") << "Spectator variable " << it->first << " is missing from the list of inputs. The returned discriminator value might not be sensible.";
     }
   }
 
   // evaluate the MVA
   value = mReader->EvaluateMVA(mMethod.c_str());
 
   return value;
 }

void TMVAEvaluator::initialize	(	const std::string &	options,
		const std::string &	method,
		const std::string &	weightFile,
		const std::vector< std::string > &	variables,
		const std::vector< std::string > &	spectators,
		bool	useGBRForest = `false`,
		bool	useAdaBoost = `false`
	)

Definition at line 15 of file TMVAEvaluator.cc.

References reco::details::loadTMVAWeights(), PATTauDiscriminationAgainstElectronMVA6_cfi::method, mGBRForest, mIsInitialized, mMethod, mReader, mSpectators, mUseAdaBoost, mUsingGBRForest, and mVariables.

 {
   // initialize the TMVA reader
   mReader.reset(new TMVA::Reader(options.c_str()));
   mReader->SetVerbose(false);
   mMethod = method;
 
   // add input variables
   for(std::vector<std::string>::const_iterator it = variables.begin(); it!=variables.end(); ++it)
   {
     mVariables.insert( std::make_pair( *it, std::make_pair( it - variables.begin(), 0. ) ) );
     mReader->AddVariable(it->c_str(), &(mVariables.at(*it).second));
   }
 
   // add spectator variables
   for(std::vector<std::string>::const_iterator it = spectators.begin(); it!=spectators.end(); ++it)
   {
     mSpectators.insert( std::make_pair( *it, std::make_pair( it - spectators.begin(), 0. ) ) );
     mReader->AddSpectator(it->c_str(), &(mSpectators.at(*it).second));
   }
 
   // load the TMVA weights
   #if ROOT_VERSION_CODE < ROOT_VERSION(6,7,0)
   mIMethod = std::unique_ptr<TMVA::IMethod>( reco::details::loadTMVAWeights(mReader.get(), mMethod.c_str(), weightFile.c_str()) );
   #else
   reco::details::loadTMVAWeights(mReader.get(), mMethod.c_str(), weightFile.c_str());
   #endif
 
   if (useGBRForest)
   {
     mGBRForest.reset( new GBRForest( dynamic_cast<TMVA::MethodBDT*>( mReader->FindMVA(mMethod.c_str()) ) ) );
 
     // now can free some memory
     mReader.reset(nullptr);
     #if ROOT_VERSION_CODE < ROOT_VERSION(6,7,0)
     mIMethod.reset(nullptr);
     #endif
 
     mUsingGBRForest = true;
     mUseAdaBoost = useAdaBoost;
   }
 
   mIsInitialized = true;
 }

void TMVAEvaluator::initializeGBRForest	(	const GBRForest *	gbrForest,
		const std::vector< std::string > &	variables,
		const std::vector< std::string > &	spectators,
		bool	useAdaBoost = `false`
	)

Definition at line 62 of file TMVAEvaluator.cc.

References mGBRForest, mIsInitialized, mSpectators, mUseAdaBoost, mUsingGBRForest, and mVariables.

Referenced by initializeGBRForest().

 {
   // add input variables
   for(std::vector<std::string>::const_iterator it = variables.begin(); it!=variables.end(); ++it)
     mVariables.insert( std::make_pair( *it, std::make_pair( it - variables.begin(), 0. ) ) );
 
   // add spectator variables
   for(std::vector<std::string>::const_iterator it = spectators.begin(); it!=spectators.end(); ++it)
     mSpectators.insert( std::make_pair( *it, std::make_pair( it - spectators.begin(), 0. ) ) );
 
   // do not take ownership if getting GBRForest from an external source
   mGBRForest = std::shared_ptr<const GBRForest>(gbrForest, [](const GBRForest*) {} );
 
   mIsInitialized = true;
   mUsingGBRForest = true;
   mUseAdaBoost = useAdaBoost;
 }

void TMVAEvaluator::initializeGBRForest	(	const edm::EventSetup &	iSetup,
		const std::string &	label,
		const std::vector< std::string > &	variables,
		const std::vector< std::string > &	spectators,
		bool	useAdaBoost = `false`
	)

Definition at line 82 of file TMVAEvaluator.cc.

References edm::EventSetup::get(), initializeGBRForest(), edm::ESHandle< class >::product(), and makeLayoutFileForGui::variables.

 {
   edm::ESHandle<GBRForest> gbrForestHandle;
 
   iSetup.get<GBRWrapperRcd>().get(label.c_str(), gbrForestHandle);
 
   initializeGBRForest(gbrForestHandle.product(), variables, spectators, useAdaBoost);
 }