LossFunction.h

Go to the documentation of this file.

// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Jan Therhaag

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : Event                                                                 *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      LossFunction and associated classes                                       *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Joerg Stelzer   <Joerg.Stelzer@cern.ch>  - CERN, Switzerland              *
 *      Peter Speckmayer <Peter.Speckmayer@cern.ch>  - CERN, Switzerland          *
 *      Jan Therhaag       <Jan.Therhaag@cern.ch>     - U of Bonn, Germany        *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *                                                                                *
 * Copyright (c) 2005-2011:                                                       *
 *      CERN, Switzerland                                                         *
 *      U. of Victoria, Canada                                                    *
 *      MPI-K Heidelberg, Germany                                                 *
 *      U. of Bonn, Germany                                                       *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://mva.sourceforge.net/license.txt)                                       *
 **********************************************************************************/

#ifndef ROOT_TMVA_LossFunction
#define ROOT_TMVA_LossFunction

//#include <iosfwd>
#include <vector>
#include <map>
#include "TMVA/Event.h"

#include "TMVA/Types.h"

// multithreading only if the compilation flag is turned on
#ifdef R__USE_IMT
#include <ROOT/TThreadExecutor.hxx>
#include <memory>
#include "TSystem.h"
#endif

namespace TMVA {

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Data Structure  used by LossFunction and LossFunctionBDT to calculate errors, targets, etc
   ///////////////////////////////////////////////////////////////////////////////////////////////

   class LossFunctionEventInfo{

   public:
      LossFunctionEventInfo(){
          trueValue = 0.;
          predictedValue = 0.;
          weight = 0.;
      };
      LossFunctionEventInfo(Double_t trueValue_, Double_t predictedValue_, Double_t weight_){
         trueValue = trueValue_;
         predictedValue = predictedValue_;
         weight = weight_;
      }
      ~LossFunctionEventInfo(){};

      Double_t trueValue;
      Double_t predictedValue;
      Double_t weight;
   };


   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Loss Function interface defining base class for general error calculations in
   // regression/classification
   ///////////////////////////////////////////////////////////////////////////////////////////////

   class LossFunction {

   public:

      // constructors
      LossFunction(){ 
        #ifdef R__USE_IMT
        fNumPoolThreads = GetNumThreadsInPool(); 
        #endif
      };
      virtual ~LossFunction(){};

      // abstract methods that need to be implemented
      virtual Double_t CalculateLoss(LossFunctionEventInfo& e) = 0;
      virtual Double_t CalculateNetLoss(std::vector<LossFunctionEventInfo>& evs) = 0;
      virtual Double_t CalculateMeanLoss(std::vector<LossFunctionEventInfo>& evs) = 0;

      virtual TString Name() = 0;
      virtual Int_t Id() = 0;

   protected:
      // #### only use multithreading if the compilation flag is turned on
      #ifdef R__USE_IMT
      UInt_t fNumPoolThreads = 1;

      // #### number of threads in the pool
      UInt_t GetNumThreadsInPool(){
         return ROOT::GetImplicitMTPoolSize();
      };
      #endif
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Loss Function interface for boosted decision trees. Inherits from LossFunction
   ///////////////////////////////////////////////////////////////////////////////////////////////

   /* Must inherit LossFunction with the virtual keyword so that we only have to implement
   * the LossFunction interface once.
   *
   *       LossFunction
   *      /            \
   *SomeLossFunction  LossFunctionBDT
   *      \            /
   *       \          /
   *    SomeLossFunctionBDT
   *
   * Without the virtual keyword the two would point to their own LossFunction objects
   * and SomeLossFunctionBDT would have to implement the virtual functions of LossFunction twice, once
   * for each object. See diagram below.
   *
   * LossFunction  LossFunction
   *     |             |
   *SomeLossFunction  LossFunctionBDT
   *      \            /
   *       \          /
   *     SomeLossFunctionBDT
   *
   * Multiple inheritance is often frowned upon. To avoid this, We could make LossFunctionBDT separate
   * from LossFunction but it really is a type of loss function.
   * We could also put LossFunction into LossFunctionBDT. In either of these scenarios, if you are doing
   * different regression methods and want to compare the Loss this makes it more convoluted.
   * I think that multiple inheritance seems justified in this case, but we could change it if it's a problem.
   * Usually it isn't a big deal with interfaces and this results in the simplest code in this case.
   */

   class LossFunctionBDT : public virtual LossFunction{

   public:

      // constructors
      LossFunctionBDT(){};
      virtual ~LossFunctionBDT(){};

      // abstract methods that need to be implemented
      virtual void Init(std::map<const TMVA::Event*, LossFunctionEventInfo>& evinfomap, std::vector<double>& boostWeights) = 0;
      virtual void SetTargets(std::vector<const TMVA::Event*>& evs, std::map< const TMVA::Event*, LossFunctionEventInfo >& evinfomap) = 0;
      virtual Double_t Target(LossFunctionEventInfo& e) = 0;
      virtual Double_t Fit(std::vector<LossFunctionEventInfo>& evs) = 0;

   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Huber loss function for regression error calculations
   ///////////////////////////////////////////////////////////////////////////////////////////////

   class HuberLossFunction : public virtual LossFunction{

   public:
      HuberLossFunction();
      HuberLossFunction(Double_t quantile);
      ~HuberLossFunction();

      // The LossFunction methods
      Double_t CalculateLoss(LossFunctionEventInfo& e);
      Double_t CalculateNetLoss(std::vector<LossFunctionEventInfo>& evs);
      Double_t CalculateMeanLoss(std::vector<LossFunctionEventInfo>& evs);

      // We go ahead and implement the simple ones
      TString Name(){ return TString("Huber"); };
      Int_t Id(){ return 0; } ;

      // Functions needed beyond the interface
      void Init(std::vector<LossFunctionEventInfo>& evs);
      Double_t CalculateQuantile(std::vector<LossFunctionEventInfo>& evs, Double_t whichQuantile, Double_t sumOfWeights, bool abs);
      Double_t CalculateSumOfWeights(std::vector<LossFunctionEventInfo>& evs);
      void SetTransitionPoint(std::vector<LossFunctionEventInfo>& evs);
      void SetSumOfWeights(std::vector<LossFunctionEventInfo>& evs);

   protected:
      Double_t fQuantile;
      Double_t fTransitionPoint;
      Double_t fSumOfWeights;
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Huber loss function with boosted decision tree functionality
   ///////////////////////////////////////////////////////////////////////////////////////////////

   // The bdt loss function implements the LossFunctionBDT interface and inherits the HuberLossFunction
   // functionality.
   class HuberLossFunctionBDT : public LossFunctionBDT, public HuberLossFunction{

   public:
      HuberLossFunctionBDT();
      HuberLossFunctionBDT(Double_t quantile):HuberLossFunction(quantile){};
      ~HuberLossFunctionBDT(){};

      // The LossFunctionBDT methods
      void Init(std::map<const TMVA::Event*, LossFunctionEventInfo>& evinfomap, std::vector<double>& boostWeights);
      void SetTargets(std::vector<const TMVA::Event*>& evs, std::map< const TMVA::Event*, LossFunctionEventInfo >& evinfomap);
      Double_t Target(LossFunctionEventInfo& e);
      Double_t Fit(std::vector<LossFunctionEventInfo>& evs);

   private:
      // some data fields
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // LeastSquares loss function for regression error calculations
   ///////////////////////////////////////////////////////////////////////////////////////////////

   class LeastSquaresLossFunction : public virtual LossFunction{

   public:
      LeastSquaresLossFunction(){};
      ~LeastSquaresLossFunction(){};

      // The LossFunction methods
      Double_t CalculateLoss(LossFunctionEventInfo& e);
      Double_t CalculateNetLoss(std::vector<LossFunctionEventInfo>& evs);
      Double_t CalculateMeanLoss(std::vector<LossFunctionEventInfo>& evs);

      // We go ahead and implement the simple ones
      TString Name(){ return TString("LeastSquares"); };
      Int_t Id(){ return 1; } ;
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Least Squares loss function with boosted decision tree functionality
   ///////////////////////////////////////////////////////////////////////////////////////////////

   // The bdt loss function implements the LossFunctionBDT interface and inherits the LeastSquaresLossFunction
   // functionality.
   class LeastSquaresLossFunctionBDT : public LossFunctionBDT, public LeastSquaresLossFunction{

   public:
      LeastSquaresLossFunctionBDT(){};
      ~LeastSquaresLossFunctionBDT(){};

      // The LossFunctionBDT methods
      void Init(std::map<const TMVA::Event*, LossFunctionEventInfo>& evinfomap, std::vector<double>& boostWeights);
      void SetTargets(std::vector<const TMVA::Event*>& evs, std::map< const TMVA::Event*, LossFunctionEventInfo >& evinfomap);
      Double_t Target(LossFunctionEventInfo& e);
      Double_t Fit(std::vector<LossFunctionEventInfo>& evs);
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Absolute Deviation loss function for regression error calculations
   ///////////////////////////////////////////////////////////////////////////////////////////////

   class AbsoluteDeviationLossFunction : public virtual LossFunction{

   public:
      AbsoluteDeviationLossFunction(){};
      ~AbsoluteDeviationLossFunction(){};

      // The LossFunction methods
      Double_t CalculateLoss(LossFunctionEventInfo& e);
      Double_t CalculateNetLoss(std::vector<LossFunctionEventInfo>& evs);
      Double_t CalculateMeanLoss(std::vector<LossFunctionEventInfo>& evs);

      // We go ahead and implement the simple ones
      TString Name(){ return TString("AbsoluteDeviation"); };
      Int_t Id(){ return 2; } ;
   };

   ///////////////////////////////////////////////////////////////////////////////////////////////
   // Absolute Deviation loss function with boosted decision tree functionality
   ///////////////////////////////////////////////////////////////////////////////////////////////

   // The bdt loss function implements the LossFunctionBDT interface and inherits the AbsoluteDeviationLossFunction
   // functionality.
   class AbsoluteDeviationLossFunctionBDT : public LossFunctionBDT, public AbsoluteDeviationLossFunction{

   public:
      AbsoluteDeviationLossFunctionBDT(){};
      ~AbsoluteDeviationLossFunctionBDT(){};

      // The LossFunctionBDT methods
      void Init(std::map<const TMVA::Event*, LossFunctionEventInfo>& evinfomap, std::vector<double>& boostWeights);
      void SetTargets(std::vector<const TMVA::Event*>& evs, std::map< const TMVA::Event*, LossFunctionEventInfo >& evinfomap);
      Double_t Target(LossFunctionEventInfo& e);
      Double_t Fit(std::vector<LossFunctionEventInfo>& evs);
   };
}

#endif