FastBDT.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Keck                                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
#ifndef INCLUDE_GUARD_BELLE2_MVA_FASTBDT_HEADER
#define INCLUDE_GUARD_BELLE2_MVA_FASTBDT_HEADER
 
#include <mva/interface/Options.h>
#include <mva/interface/Teacher.h>
#include <mva/interface/Expert.h>
 
#include <FastBDT.h>
 
#if FastBDT_VERSION_MAJOR >= 3
#include <FastBDT_IO.h>
#else
#include <IO.h>
#endif
 
#if FastBDT_VERSION_MAJOR >= 5
#include <Classifier.h>
#endif
 
// Template specialization to fix NAN sort bug of FastBDT in upto Version 3.2
#if FastBDT_VERSION_MAJOR <= 3 && FastBDT_VERSION_MINOR <= 2
namespace FastBDT {
  template<>
  bool compareIncludingNaN(float i, float j);
}
#endif
 
namespace Belle2 {
  namespace MVA {
 
 
    bool isValidSignal(const std::vector<bool>& Signals);
 
    class FastBDTOptions : public SpecificOptions {
 
    public:
      virtual void load(const boost::property_tree::ptree& pt) override;
 
      virtual void save(boost::property_tree::ptree& pt) const override;
 
      virtual po::options_description getDescription() override;
 
      virtual std::string getMethod() const override { return "FastBDT"; }
 
      unsigned int m_nTrees = 200; 
      unsigned int m_nCuts = 8; 
      unsigned int m_nLevels = 3; 
      double m_shrinkage = 0.1; 
      double m_randRatio = 0.5; 
#if FastBDT_VERSION_MAJOR >= 5
      std::vector<unsigned int>
      m_individual_nCuts; 
      double m_flatnessLoss = -1.0; 
      bool m_sPlot = false; 
      bool m_purityTransformation = false; 
      std::vector<bool>
      m_individualPurityTransformation; 
#endif
    };
 
 
    class FastBDTTeacher : public Teacher {
 
    public:
      FastBDTTeacher(const GeneralOptions& general_options, const FastBDTOptions& specific_options);
 
      virtual Weightfile train(Dataset& training_data) const override;
 
    private:
      FastBDTOptions m_specific_options; 
    };
 
 
    class FastBDTExpert : public MVA::Expert {
 
    public:
      virtual void load(Weightfile& weightfile) override;
 
      virtual std::vector<float> apply(Dataset& test_data) const override;
 
    private:
      FastBDTOptions m_specific_options; 
#if FastBDT_VERSION_MAJOR >= 3
#if FastBDT_VERSION_MAJOR >= 5
      bool m_use_simplified_interface = false; 
      FastBDT::Classifier m_classifier; 
#endif
      FastBDT::Forest<float> m_expert_forest; 
#else
      FastBDT::Forest m_expert_forest; 
      std::vector<FastBDT::FeatureBinning<float>> m_expert_feature_binning; 
#endif
    };
 
  }
}
#endif