Regression.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2018 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Nils Braun                                               *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <mva/interface/Dataset.h>
#include <mva/interface/Expert.h>
#include <mva/interface/Options.h>
#include <mva/interface/Teacher.h>
#include <mva/interface/Weightfile.h>
 
#include <framework/logging/Logger.h>
 
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/program_options.hpp>
#include <vector>
 
namespace Belle2 {
  namespace MVA {
 
    template<class BaseClassifierOptions>
    class RegressionOptions : public SpecificOptions {
    public:
      void load(const boost::property_tree::ptree& pt) override;
 
      void save(boost::property_tree::ptree& pt) const override;
 
      po::options_description getDescription() override;
 
      const BaseClassifierOptions& getBaseClassifierOptions() const;
 
      BaseClassifierOptions& getBaseClassifierOptions();
 
      unsigned int getMaximalBinNumber() const;
 
      void setMaximalBinNumber(unsigned int maximalBinNumber);
 
    private:
      BaseClassifierOptions m_baseClassifierOptions;
      unsigned int m_numberOfBins = 4;
    };
 
    class RegressionDataSet : public Dataset {
    public:
      RegressionDataSet(const GeneralOptions& general_options, Dataset* dataSet, double cutValue);
 
      unsigned int getNumberOfFeatures() const override;
 
      unsigned int getNumberOfEvents() const override;
 
      unsigned int getNumberOfSpectators() const override;
 
      void loadEvent(unsigned int iEvent) override;
 
      std::vector<float> getFeature(unsigned int iFeature) override;
 
      std::vector<float> getSpectator(unsigned int iSpectator) override;
 
      std::vector<float> getWeights() override;
 
      std::vector<float> getTargets() override;
 
    private:
      double m_cutValue;
 
      Dataset* m_childDataSet;
    };
 
    template<class BaseClassifierTeacher, class RegressionClassifierOptions>
    class RegressionTeacher : public Teacher {
    public:
      RegressionTeacher(const GeneralOptions& general_options,
                        const RegressionClassifierOptions& specific_options);
 
      Weightfile train(Dataset& training_data) const override;
 
    private:
      RegressionClassifierOptions m_specific_options;
      BaseClassifierTeacher m_baseClassifierTeacher;
    };
 
    template<class BaseClassifierExpert, class RegressionClassifierOptions>
    class RegressionExpert : public Expert {
    public:
      void load(Weightfile& weightfile) override;
 
      std::vector<float> apply(Dataset& test_data) const override;
 
    private:
      std::vector<BaseClassifierExpert> m_baseClassifierExperts;
    };
  }
}
 
 
template<class BaseClassifierOptions>
void Belle2::MVA::RegressionOptions<BaseClassifierOptions>::load(const boost::property_tree::ptree& pt)
{
  m_numberOfBins = pt.get<unsigned int>(getMethod() + "_numberOfBins");
}
 
template<class BaseClassifierOptions>
unsigned int Belle2::MVA::RegressionOptions<BaseClassifierOptions>::getMaximalBinNumber() const
{
  return m_numberOfBins;
}
 
template<class BaseClassifierOptions>
void Belle2::MVA::RegressionOptions<BaseClassifierOptions>::setMaximalBinNumber(unsigned int maximalBinNumber)
{
  m_numberOfBins = maximalBinNumber;
}
 
template<class BaseClassifierOptions>
const BaseClassifierOptions& Belle2::MVA::RegressionOptions<BaseClassifierOptions>::getBaseClassifierOptions() const
{
  return m_baseClassifierOptions;
}
 
template<class BaseClassifierOptions>
BaseClassifierOptions& Belle2::MVA::RegressionOptions<BaseClassifierOptions>::getBaseClassifierOptions()
{
  return m_baseClassifierOptions;
}
 
template<class BaseClassifierOptions>
void Belle2::MVA::RegressionOptions<BaseClassifierOptions>::save(boost::property_tree::ptree& pt) const
{
  pt.put(getMethod() + "_numberOfBins", m_numberOfBins);
}
 
template<class BaseClassifierOptions>
po::options_description Belle2::MVA::RegressionOptions<BaseClassifierOptions>::getDescription()
{
  auto description = getBaseClassifierOptions().getDescription();
 
  description.add_options()
  ("numberOfBins", po::value<unsigned int>(&m_numberOfBins),
   "Number of bins to split the target variable into");
 
  return description;
}
 
template<class BaseClassifierTeacher, class RegressionClassifierOptions>
Belle2::MVA::Weightfile Belle2::MVA::RegressionTeacher<BaseClassifierTeacher, RegressionClassifierOptions>::train(
  Belle2::MVA::Dataset& training_data) const
{
  Weightfile weightfile;
  weightfile.addOptions(m_general_options);
  weightfile.addOptions(m_specific_options);
 
  for (unsigned int binNumber = 1; binNumber < m_specific_options.getMaximalBinNumber(); binNumber++) {
    RegressionDataSet specificDataSet(m_general_options, &training_data,
                                      1.0 / m_specific_options.getMaximalBinNumber() * binNumber);
    Weightfile specificWeightFile = m_baseClassifierTeacher.train(specificDataSet);
 
    std::string file = weightfile.generateFileName();
    Weightfile::saveToXMLFile(specificWeightFile, file);
    weightfile.addFile("BaseClassifier_WeightFile_" + std::to_string(binNumber), file);
  }
  return weightfile;
}
 
template<class BaseClassifierTeacher, class RegressionClassifierOptions>
Belle2::MVA::RegressionTeacher<BaseClassifierTeacher, RegressionClassifierOptions>::RegressionTeacher(
  const Belle2::MVA::GeneralOptions& general_options,
  const RegressionClassifierOptions& specific_options) :
  Teacher(general_options), m_specific_options(specific_options),
  m_baseClassifierTeacher(general_options, specific_options.getBaseClassifierOptions())
{
}
 
template<class BaseClassifierExpert, class RegressionClassifierOptions>
void Belle2::MVA::RegressionExpert<BaseClassifierExpert, RegressionClassifierOptions>::load(Weightfile& weightfile)
{
  RegressionClassifierOptions specific_options;
  weightfile.getOptions(specific_options);
 
  m_baseClassifierExperts.resize(specific_options.getMaximalBinNumber());
  for (unsigned int binNumber = 1; binNumber < specific_options.getMaximalBinNumber(); binNumber++) {
    std::string file = weightfile.generateFileName();
    weightfile.getFile("BaseClassifier_WeightFile_" + std::to_string(binNumber), file);
 
    auto specificWeightFile = Weightfile::loadFromXMLFile(file);
    m_baseClassifierExperts[binNumber].load(specificWeightFile);
  }
}
 
template<class BaseClassifierExpert, class RegressionClassifierOptions>
std::vector<float> Belle2::MVA::RegressionExpert<BaseClassifierExpert, RegressionClassifierOptions>::apply(
  Dataset& test_data) const
{
  std::vector<float> sum;
  for (const auto& expert : m_baseClassifierExperts) {
    if (sum.empty()) {
      // First time we do not need to add something, but just replace
      sum = expert.apply(test_data);
      continue;
    }
 
    const auto& expertResult = expert.apply(test_data);
    if (sum.size() != expertResult.size()) {
      B2FATAL("There is one expert in the list that returned not the same number of results than the others!");
    }
 
    for (unsigned int index = 0; index < sum.size(); index++) {
      sum[index] += expertResult[index];
    }
  }
 
  for (unsigned int index = 0; index < sum.size(); index++) {
    sum[index] /= m_baseClassifierExperts.size();
  }
 
  return sum;
}