Method Class Reference

Public Member Functions
def	__init__ (self, identifier)
def	train_teacher (self, datafiles, treename, general_options=None, specific_options=None)
def	apply_expert (self, datafiles, treename)

Public Attributes
	identifier
	Identifier of the method.
	weightfile
	Weightfile of the method.
	general_options
	General options of the method.
	specific_options
	Specific options of the method.
	importances
	Dictionary of the variable importances calculated by the method.
	variables
	List of variables sorted by their importance.
	root_variables
	List of the variable importances calculated by the method, but with the root compatible variable names.
	root_importances
	Dictionary of the variables sorted by their importance but with root compatoble variable names.
	description
	Description of the method as a xml string returned by basf2_mva.info.
	spectators
	List of spectators.
	root_spectators
	List of spectators with root compatible names.

Detailed Description

Wrapper class providing an interface to the method stored under the given identifier.
It loads the Options, can apply the expert and train new ones using the current as a prototype.
This class is used by the basf_mva_evaluation tools

Definition at line 129 of file basf2_mva_util.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			identifier
	)

Load a method stored under the given identifier
@param identifier identifying the method

Definition at line 136 of file basf2_mva_util.py.

    def __init__(self, identifier):
        """
        Load a method stored under the given identifier
        @param identifier identifying the method
        """
        # Always avoid the top-level 'import ROOT'.
        import ROOT  # noqa
        # Initialize all the available interfaces
        ROOT.Belle2.MVA.AbstractInterface.initSupportedInterfaces()
        
        self.identifier = identifier
        
        self.weightfile = ROOT.Belle2.MVA.Weightfile.load(self.identifier)
        
        self.general_options = basf2_mva.GeneralOptions()
        self.general_options.load(self.weightfile.getXMLTree())
 
        # This piece of code should be correct but leads to random segmentation faults
        # inside python, llvm or pyroot, therefore we use the more dirty code below
        # Ideas why this is happening:
        # 1. Ownership of the unique_ptr returned by getOptions()
        # 2. Some kind of object slicing, although pyroot identifies the correct type
        # 3. Bug in pyroot
        # interfaces = ROOT.Belle2.MVA.AbstractInterface.getSupportedInterfaces()
        # self.interface = interfaces[self.general_options.m_method]
        # self.specific_options = self.interface.getOptions()
 
        
        self.specific_options = None
        if self.general_options.m_method == "FastBDT":
            self.specific_options = basf2_mva.FastBDTOptions()
        elif self.general_options.m_method == "TMVAClassification":
            self.specific_options = basf2_mva.TMVAOptionsClassification()
        elif self.general_options.m_method == "TMVARegression":
            self.specific_options = basf2_mva.TMVAOptionsRegression()
        elif self.general_options.m_method == "FANN":
            self.specific_options = basf2_mva.FANNOptions()
        elif self.general_options.m_method == "Python":
            self.specific_options = basf2_mva.PythonOptions()
        elif self.general_options.m_method == "PDF":
            self.specific_options = basf2_mva.PDFOptions()
        elif self.general_options.m_method == "Combination":
            self.specific_options = basf2_mva.CombinationOptions()
        elif self.general_options.m_method == "Reweighter":
            self.specific_options = basf2_mva.ReweighterOptions()
        elif self.general_options.m_method == "Trivial":
            self.specific_options = basf2_mva.TrivialOptions()
        else:
            raise RuntimeError("Unknown method " + self.general_options.m_method)
 
        self.specific_options.load(self.weightfile.getXMLTree())
 
        variables = [str(v) for v in self.general_options.m_variables]
        importances = self.weightfile.getFeatureImportance()
 
        
        self.importances = {k: importances[k] for k in variables}
        
        self.variables = list(sorted(variables, key=lambda v: self.importances.get(v, 0.0)))
        
        self.root_variables = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.variables]
        
        self.root_importances = {k: importances[k] for k in self.root_variables}
        
        self.description = str(basf2_mva.info(self.identifier))
        
        self.spectators = [str(v) for v in self.general_options.m_spectators]
        
        self.root_spectators = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.spectators]
 

Member Function Documentation

apply_expert()

def apply_expert	(		self,
			datafiles,
			treename
	)

Apply the expert of the method to data and return the calculated probability and the target
@param datafiles the datafiles
@param treename the name of the tree containing the data

Definition at line 236 of file basf2_mva_util.py.

train_teacher()

def train_teacher	(		self,
			datafiles,
			treename,
			general_options = None,
			specific_options = None
	)

Train a new method using this method as a prototype
@param datafiles the training datafiles
@param treename the name of the tree containing the training data
@param general_options general options given to basf2_mva.teacher
  (if None the options of this method are used)
@param specific_options specific options given to basf2_mva.teacher
  (if None the options of this method are used)

Definition at line 206 of file basf2_mva_util.py.

---

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

• mva/scripts/basf2_mva_util.py