Public Member Functions
	__init__ (self, identifier)

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

	apply_expert (self, datafiles, treename)

Public Attributes
	identifier = identifier
	Identifier of the method.

	weightfile = ROOT.Belle2.MVA.Weightfile.load(self.identifier)
	Weightfile of the method.

	general_options = basf2_mva.GeneralOptions()
	General options of the method.

	specific_options = None
	Specific options of the method.

dict	importances = {k: importances[k] for k in variables}
	Dictionary of the variable importances calculated by the method.

	variables = list(sorted(variables, key=lambda v: self.importances.get(v, 0.0)))
	List of variables sorted by their importance.

list	root_variables = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.variables]
	List of the variable importances calculated by the method, but with the root compatible variable names.

dict	root_importances = {k: importances[k] for k in self.root_variables}
	Dictionary of the variables sorted by their importance but with root compatoble variable names.

	description = str(basf2_mva.info(self.identifier))
	Description of the method as a xml string returned by basf2_mva.info.

list	spectators = [str(v) for v in self.general_options.m_spectators]
	List of spectators.

list	root_spectators = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.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 141 of file basf2_mva_util.py.

Constructor & Destructor Documentation

◆ init()

__init__	(		self,
			identifier )

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

Definition at line 148 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()

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 248 of file basf2_mva_util.py.

    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
        """
        import ROOT  # noqa
        if isinstance(datafiles, str):
            datafiles = [datafiles]
        with tempfile.TemporaryDirectory() as tempdir:
            identifier = tempdir + "/weightfile.xml"
            ROOT.Belle2.MVA.Weightfile.save(self.weightfile, identifier)
 
            rootfilename = tempdir + '/expert.root'
            basf2_mva.expert(basf2_mva.vector(identifier),
                             basf2_mva.vector(*datafiles),
                             treename,
                             rootfilename)
            chain = ROOT.TChain("variables")
            chain.Add(rootfilename)
 
            expert_target = identifier + '_' + self.general_options.m_target_variable
            stripped_expert_target = self.identifier + '_' + self.general_options.m_target_variable
 
            output_names = [self.identifier]
            branch_names = [
                    ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(identifier),
                    ]
            if self.general_options.m_nClasses > 2:
                output_names = [self.identifier+f'_{i}' for i in range(self.general_options.m_nClasses)]
                branch_names = [
                    ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(
                        identifier +
                        f'_{i}') for i in range(
                        self.general_options.m_nClasses)]
 
            d = chain2dict(
                chain,
                [*branch_names, ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(expert_target)],
                [*output_names, stripped_expert_target])
 
        return (d[str(self.identifier)] if self.general_options.m_nClasses <= 2 else np.array([d[x]
                for x in output_names]).T), d[stripped_expert_target]

◆ train_teacher()

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 218 of file basf2_mva_util.py.

    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)
        """
        # Always avoid the top-level 'import ROOT'.
        import ROOT  # noqa
        if isinstance(datafiles, str):
            datafiles = [datafiles]
        if general_options is None:
            general_options = self.general_options
        if specific_options is None:
            specific_options = self.specific_options
 
        with tempfile.TemporaryDirectory() as tempdir:
            identifier = tempdir + "/weightfile.xml"
 
            general_options.m_datafiles = basf2_mva.vector(*datafiles)
            general_options.m_identifier = identifier
 
            basf2_mva.teacher(general_options, specific_options)
 
            method = Method(identifier)
        return method
 

Member Data Documentation

◆ description

description = str(basf2_mva.info(self.identifier))

Description of the method as a xml string returned by basf2_mva.info.

Definition at line 212 of file basf2_mva_util.py.

◆ general_options

general_options = basf2_mva.GeneralOptions()

General options of the method.

Definition at line 162 of file basf2_mva_util.py.

◆ identifier

identifier = identifier

Identifier of the method.

Definition at line 158 of file basf2_mva_util.py.

◆ importances

dict importances = {k: importances[k] for k in variables}

Dictionary of the variable importances calculated by the method.

Definition at line 204 of file basf2_mva_util.py.

◆ root_importances

dict root_importances = {k: importances[k] for k in self.root_variables}

Dictionary of the variables sorted by their importance but with root compatoble variable names.

Definition at line 210 of file basf2_mva_util.py.

◆ root_spectators

list root_spectators = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.spectators]

List of spectators with root compatible names.

Definition at line 216 of file basf2_mva_util.py.

◆ root_variables

list root_variables = [ROOT.Belle2.MakeROOTCompatible.makeROOTCompatible(v) for v in self.variables]

List of the variable importances calculated by the method, but with the root compatible variable names.

Definition at line 208 of file basf2_mva_util.py.

◆ specific_options

specific_options = None

Specific options of the method.

Definition at line 176 of file basf2_mva_util.py.

◆ spectators

list spectators = [str(v) for v in self.general_options.m_spectators]

List of spectators.

Definition at line 214 of file basf2_mva_util.py.

◆ variables

variables = list(sorted(variables, key=lambda v: self.importances.get(v, 0.0)))

List of variables sorted by their importance.

Definition at line 206 of file basf2_mva_util.py.

◆ weightfile

weightfile = ROOT.Belle2.MVA.Weightfile.load(self.identifier)

Weightfile of the method.

Definition at line 160 of file basf2_mva_util.py.

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

mva/scripts/basf2_mva_util.py

Public Member Functions

Public Attributes