Teacher for the FastBDT MVA method. More...

#include <FastBDT.h>

Inheritance diagram for FastBDTTeacher:

Public Member Functions
	FastBDTTeacher (const GeneralOptions &general_options, const FastBDTOptions &specific_options)
	Constructs a new teacher using the GeneralOptions and specific options of this training.

virtual Weightfile	train (Dataset &training_data) const override
	Train a mva method using the given dataset returning a Weightfile.

Protected Attributes
GeneralOptions	m_general_options
	GeneralOptions containing all shared options.

Private Attributes
FastBDTOptions	m_specific_options
	Method specific options.

Detailed Description

Teacher for the FastBDT MVA method.

Definition at line 80 of file FastBDT.h.

Constructor & Destructor Documentation

◆ FastBDTTeacher()

FastBDTTeacher	(	const GeneralOptions &	general_options,
		const FastBDTOptions &	specific_options
	)

Constructs a new teacher using the GeneralOptions and specific options of this training.

Parameters

general_options	defining all shared options
specific_options	defininf all method specific options

Definition at line 117 of file FastBDT.cc.

118 : Teacher(general_options),

119 m_specific_options(specific_options) { }

Belle2::MVA::FastBDTTeacher::m_specific_options

FastBDTOptions m_specific_options

Method specific options.

Definition: FastBDT.h:97

Belle2::MVA::Teacher::Teacher

Teacher(const GeneralOptions &general_options)

Constructs a new teacher using the GeneralOptions for this training.

Definition: Teacher.cc:18

Member Function Documentation

◆ train()

Weightfile train ( Dataset & training_data ) const

overridevirtual

Train a mva method using the given dataset returning a Weightfile.

Parameters

training_data used to train the method

Implements Teacher.

Definition at line 121 of file FastBDT.cc.

    {
      if (training_data.getNumberOfEvents() > 5e+6) {
        B2WARNING("Number of events for training exceeds 5 million. FastBDT performance starts getting worse when the number reaches O(10^7).");
      }
 
      unsigned int numberOfFeatures = training_data.getNumberOfFeatures();
      unsigned int numberOfSpectators = training_data.getNumberOfSpectators();
 
      if (m_specific_options.m_individual_nCuts.size() != 0
          and m_specific_options.m_individual_nCuts.size() != numberOfFeatures + numberOfSpectators) {
        B2ERROR("You provided individual nCut values for each feature and spectator, but the total number of provided cuts is not same as as the total number of features and spectators.");
      }
 
      std::vector<bool> individualPurityTransformation = m_specific_options.m_individualPurityTransformation;
      if (m_specific_options.m_purityTransformation) {
        if (individualPurityTransformation.size() == 0) {
          for (unsigned int i = 0; i < numberOfFeatures; ++i) {
            individualPurityTransformation.push_back(true);
          }
        }
      }
 
      std::vector<unsigned int> individual_nCuts = m_specific_options.m_individual_nCuts;
      if (individual_nCuts.size() == 0) {
        for (unsigned int i = 0; i < numberOfFeatures + numberOfSpectators; ++i) {
          individual_nCuts.push_back(m_specific_options.m_nCuts);
        }
      }
 
      FastBDT::Classifier classifier(m_specific_options.m_nTrees,  m_specific_options.m_nLevels, individual_nCuts,
                                     m_specific_options.m_shrinkage, m_specific_options.m_randRatio,
                                     m_specific_options.m_sPlot, m_specific_options.m_flatnessLoss, individualPurityTransformation,
                                     numberOfSpectators, true);
 
      std::vector<std::vector<float>> X(numberOfFeatures + numberOfSpectators);
      const auto& y = training_data.getSignals();
      if (not isValidSignal(y)) {
        B2FATAL("The training data is not valid. It only contains one class instead of two.");
      }
      const auto& w = training_data.getWeights();
      for (unsigned int i = 0; i < numberOfFeatures; ++i) {
        X[i] = training_data.getFeature(i);
      }
      for (unsigned int i = 0; i < numberOfSpectators; ++i) {
        X[i + numberOfFeatures] = training_data.getSpectator(i);
      }
      classifier.fit(X, y, w);
 
      Weightfile weightfile;
      std::string custom_weightfile = weightfile.generateFileName();
      std::fstream file(custom_weightfile, std::ios_base::out | std::ios_base::trunc);
 
      file << classifier << std::endl;
      file.close();
 
      weightfile.addOptions(m_general_options);
      weightfile.addOptions(m_specific_options);
      weightfile.addFile("FastBDT_Weightfile", custom_weightfile);
      weightfile.addSignalFraction(training_data.getSignalFraction());
 
      std::map<std::string, float> importance;
      for (auto& pair : classifier.GetVariableRanking()) {
        importance[m_general_options.m_variables[pair.first]] = pair.second;
      }
      weightfile.addFeatureImportance(importance);
 
      return weightfile;
 
    }

Member Data Documentation

◆ m_general_options

GeneralOptions m_general_options

protectedinherited

GeneralOptions containing all shared options.

Definition at line 49 of file Teacher.h.

◆ m_specific_options

FastBDTOptions m_specific_options

private

Method specific options.

Definition at line 97 of file FastBDT.h.

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

mva/methods/include/FastBDT.h
mva/methods/src/FastBDT.cc

Public Member Functions

Protected Attributes

Private Attributes