FastBDTExpert Class Reference

Expert for the FastBDT MVA method. More...

#include <FastBDT.h>

Inheritance diagram for FastBDTExpert:

Collaboration diagram for FastBDTExpert:

Public Member Functions
virtual void	load (Weightfile &weightfile) override
	Load the expert from a Weightfile.
virtual std::vector< float >	apply (Dataset &test_data) const override
	Apply this expert onto a dataset.
virtual std::vector< std::vector< float > >	applyMulticlass (Dataset &test_data) const
	Apply this m_expert onto a dataset.

Protected Attributes
GeneralOptions	m_general_options
	General options loaded from the weightfile.

Private Attributes
FastBDTOptions	m_specific_options
	Method specific options.
FastBDT::Forest	m_expert_forest
	Forest Expert.
std::vector< FastBDT::FeatureBinning< float > >	m_expert_feature_binning
	Forest feature binning.

Detailed Description

Expert for the FastBDT MVA method.

Definition at line 122 of file FastBDT.h.

Member Function Documentation

apply()

std::vector< float > apply ( Dataset &  test_data ) const

overridevirtual

Apply this expert onto a dataset.

Parameters

test_data

dataset

Implements Expert.

Definition at line 415 of file FastBDT.cc.

    {
 
      std::vector<float> probabilities(test_data.getNumberOfEvents());
      for (unsigned int iEvent = 0; iEvent < test_data.getNumberOfEvents(); ++iEvent) {
        test_data.loadEvent(iEvent);
#if FastBDT_VERSION_MAJOR >= 3
#if FastBDT_VERSION_MAJOR >= 5
        if (m_use_simplified_interface)
          probabilities[iEvent] = m_classifier.predict(test_data.m_input);
        else
          probabilities[iEvent] = m_expert_forest.Analyse(test_data.m_input);
#else
        probabilities[iEvent] = m_expert_forest.Analyse(test_data.m_input);
#endif
#else
        std::vector<unsigned int> bins(m_expert_feature_binning.size());
        for (unsigned int iFeature = 0; iFeature < m_expert_feature_binning.size(); ++iFeature) {
          bins[iFeature] = m_expert_feature_binning[iFeature].ValueToBin(test_data.m_input[iFeature]);
        }
        probabilities[iEvent] = m_expert_forest.Analyse(bins);
#endif
      }
 
      return probabilities;
 
    }

applyMulticlass()

virtual std::vector< std::vector< float > > applyMulticlass ( Dataset &  test_data ) const

inlinevirtualinherited

Apply this m_expert onto a dataset.

Multiclass mode. Not pure virtual, since not all derived classes to re-implement this.

Parameters

test_data

dataset.

Returns

vector of size N=test_data.getNumberOfEvents() with N=m_classes.size() scores for each event in the dataset.

Reimplemented in PythonExpert, TMVAExpertMulticlass, and TrivialExpert.

Definition at line 56 of file Expert.h.

      {
 
        B2ERROR("Attempted to call applyMulticlass() of the abstract base class MVA::Expert. All methods that support multiclass classification should override this definition.");
        (void) test_data;
 
        return std::vector<std::vector<float>>();
      };

load()

void load ( Weightfile &  weightfile )

overridevirtual

Load the expert from a Weightfile.

Parameters

weightfile

containing all information necessary to build the expert

Implements Expert.

Definition at line 322 of file FastBDT.cc.

    {
 
      std::string custom_weightfile = weightfile.generateFileName();
      weightfile.getFile("FastBDT_Weightfile", custom_weightfile);
      std::fstream file(custom_weightfile, std::ios_base::in);
 
      int version = weightfile.getElement<int>("FastBDT_version", 0);
      B2DEBUG(100, "FastBDT Weightfile Version " << version);
      if (version < 2) {
#if FastBDT_VERSION_MAJOR >= 3
        std::stringstream s;
        {
          std::string t;
          std::fstream file2(custom_weightfile, std::ios_base::in);
          getline(file2, t);
          s << t;
        }
        int dummy;
        // Try to read to integers, if this is successful we have a old weightfile with a Feature Binning before the Tree.
        if (!(s >> dummy >> dummy)) {
          B2DEBUG(100, "FastBDT: I read a new weightfile of FastBDT using the new FastBDT version 3. Everything fine!");
          // New format since version 3
          m_expert_forest = FastBDT::readForestFromStream<float>(file);
        } else {
          B2INFO("FastBDT: I read an old weightfile of FastBDT using the new FastBDT version 3."
                 "I will convert your FastBDT on-the-fly to the new version."
                 "Retrain the classifier to get rid of this message");
          // Old format before version 3
          // We read in first the feature binnings and than rewrite the tree
          std::vector<FastBDT::FeatureBinning<float>> feature_binnings;
          file >> feature_binnings;
          double F0;
          file >> F0;
          double shrinkage;
          file >> shrinkage;
          // This parameter was not available in the old version
          bool transform2probability = true;
          FastBDT::Forest<unsigned int> temp_forest(shrinkage, F0, transform2probability);
          unsigned int size;
          file >> size;
          for (unsigned int i = 0; i < size; ++i) {
            temp_forest.AddTree(FastBDT::readTreeFromStream<unsigned int>(file));
          }
 
          FastBDT::Forest<float> cleaned_forest(temp_forest.GetShrinkage(), temp_forest.GetF0(), temp_forest.GetTransform2Probability());
          for (auto& tree : temp_forest.GetForest()) {
            cleaned_forest.AddTree(FastBDT::removeFeatureBinningTransformationFromTree(tree, feature_binnings));
          }
          m_expert_forest = cleaned_forest;
        }
#else
        B2INFO("FastBDT: I read an old weightfile of FastBDT using the old FastBDT version."
               "I try to fix the weightfile first to avoid problems due to NaN and inf values."
               "Consider to switch to the newer version of FastBDT (newer externals)");
        // Check for nan or inf in file and replace with 0
        std::stringstream s;
        std::string t;
        while (getline(file, t)) {
          size_t f = 0;
 
          while ((f = t.find("inf", f)) != std::string::npos) {
            t.replace(f, std::string("inf").length(), std::string("0.0"));
            f += std::string("0.0").length();
            B2WARNING("Found infinity in FastBDT weightfile, I replace it with 0 to prevent horrible crashes, this is fixed in the newer version");
          }
          f = 0;
          while ((f = t.find("nan", f)) != std::string::npos) {
            t.replace(f, std::string("nan").length(), std::string("0.0"));
            f += std::string("0.0").length();
            B2WARNING("Found nan in FastBDT weightfile, I replace it with 0 to prevent horrible crashes, this is fixed in the newer version");
          }
          s << t + '\n';
        }
        s >> m_expert_feature_binning;
        m_expert_forest = FastBDT::readForestFromStream(s);
#endif
      }
#if FastBDT_VERSION_MAJOR >= 5
      else {
        m_use_simplified_interface = true;
        m_classifier = FastBDT::Classifier(file);
      }
#else
      else {
        B2ERROR("Unknown Version 2 of Weightfile, please use a more recent FastBDT version");
      }
#endif
      file.close();
 
      weightfile.getOptions(m_specific_options);
    }

Member Data Documentation

m_expert_feature_binning

std::vector<FastBDT::FeatureBinning<float> > m_expert_feature_binning

private

Forest feature binning.

Definition at line 147 of file FastBDT.h.

m_expert_forest

FastBDT::Forest m_expert_forest

private

Forest Expert.

Definition at line 146 of file FastBDT.h.

m_general_options

GeneralOptions m_general_options

protectedinherited

General options loaded from the weightfile.

Definition at line 70 of file Expert.h.

m_specific_options

FastBDTOptions m_specific_options

private

Method specific options.

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