TMVAClassification_RuleFit.class.C

Go to the documentation of this file.

// Class: ReadRuleFit
// Automatically generated by MethodBase::MakeClass
//

/* configuration options =====================================================

#GEN -*-*-*-*-*-*-*-*-*-*-*- general info -*-*-*-*-*-*-*-*-*-*-*-

Method         : RuleFit::RuleFit
TMVA Release   : 4.2.1         [262657]
ROOT Release   : 6.12/07       [396295]
Creator        : sftnight
Date           : Sat Sep 29 23:25:19 2018
Host           : Linux ec-ubuntu-14-04-x86-64-2 3.13.0-157-generic #207-Ubuntu SMP Mon Aug 20 16:44:59 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
Dir            : /mnt/build/workspace/root-makedoc-v612/rootspi/rdoc/src/v6-12-00-patches/documentation/doxygen
Training events: 2000
Analysis type  : [Classification]


#OPT -*-*-*-*-*-*-*-*-*-*-*-*- options -*-*-*-*-*-*-*-*-*-*-*-*-

# Set by User:
V: "False" [Verbose output (short form of "VerbosityLevel" below - overrides the latter one)]
H: "True" [Print method-specific help message]
GDTau: "-1.000000e+00" [Gradient-directed (GD) path: default fit cut-off]
GDTauPrec: "1.000000e-02" [GD path: precision of tau]
GDStep: "1.000000e-02" [GD path: step size]
GDNSteps: "10000" [GD path: number of steps]
GDErrScale: "1.020000e+00" [Stop scan when error > scale*errmin]
fEventsMin: "1.000000e-02" [Minimum fraction of events in a splittable node]
fEventsMax: "5.000000e-01" [Maximum fraction of events in a splittable node]
nTrees: "20" [Number of trees in forest.]
RuleMinDist: "1.000000e-03" [Minimum distance between rules]
MinImp: "1.000000e-03" [Minimum rule importance accepted]
Model: "modrulelinear" [Model to be used]
RuleFitModule: "rftmva" [Which RuleFit module to use]
# Default:
VerbosityLevel: "Default" [Verbosity level]
VarTransform: "None" [List of variable transformations performed before training, e.g., "D_Background,P_Signal,G,N_AllClasses" for: "Decorrelation, PCA-transformation, Gaussianisation, Normalisation, each for the given class of events ('AllClasses' denotes all events of all classes, if no class indication is given, 'All' is assumed)"]
CreateMVAPdfs: "False" [Create PDFs for classifier outputs (signal and background)]
IgnoreNegWeightsInTraining: "False" [Events with negative weights are ignored in the training (but are included for testing and performance evaluation)]
LinQuantile: "2.500000e-02" [Quantile of linear terms (removes outliers)]
GDPathEveFrac: "5.000000e-01" [Fraction of events used for the path search]
GDValidEveFrac: "5.000000e-01" [Fraction of events used for the validation]
ForestType: "adaboost" [Method to use for forest generation (AdaBoost or RandomForest)]
RFWorkDir: "./rulefit" [Friedman's RuleFit module (RFF): working dir]
RFNrules: "2000" [RFF: Mximum number of rules]
RFNendnodes: "4" [RFF: Average number of end nodes]
##


#VAR -*-*-*-*-*-*-*-*-*-*-*-* variables *-*-*-*-*-*-*-*-*-*-*-*-

NVar 4
var1+var2                     myvar1                        myvar1                        myvar1                                                          'F'    [-8.14423561096,7.26972866058]
var1-var2                     myvar2                        myvar2                        Expression 2                                                    'F'    [-3.96643972397,4.0258936882]
var3                          var3                          var3                          Variable 3                    units                             'F'    [-5.03730010986,4.27845287323]
var4                          var4                          var4                          Variable 4                    units                             'F'    [-5.95050764084,4.64035463333]
NSpec 2
var1*2                        spec1                         spec1                         Spectator 1                   units                             'F'    [-9.91655540466,8.67800140381]
var1*3                        spec2                         spec2                         Spectator 2                   units                             'F'    [-14.874833107,13.0170021057]


============================================================================ */

#include <array>
#include <vector>
#include <cmath>
#include <string>
#include <iostream>

#ifndef IClassifierReader__def
#define IClassifierReader__def

class IClassifierReader {

 public:

   // constructor
   IClassifierReader() : fStatusIsClean( true ) {}
   virtual ~IClassifierReader() {}

   // return classifier response
   virtual double GetMvaValue( const std::vector<double>& inputValues ) const = 0;

   // returns classifier status
   bool IsStatusClean() const { return fStatusIsClean; }

 protected:

   bool fStatusIsClean;
};

#endif

class ReadRuleFit : public IClassifierReader {

 public:

   // constructor
   ReadRuleFit( std::vector<std::string>& theInputVars ) 
      : IClassifierReader(),
        fClassName( "ReadRuleFit" ),
        fNvars( 4 ),
        fIsNormalised( false )
   {      
      // the training input variables
      const char* inputVars[] = { "var1+var2", "var1-var2", "var3", "var4" };

      // sanity checks
      if (theInputVars.size() <= 0) {
         std::cout << "Problem in class \"" << fClassName << "\": empty input vector" << std::endl;
         fStatusIsClean = false;
      }

      if (theInputVars.size() != fNvars) {
         std::cout << "Problem in class \"" << fClassName << "\": mismatch in number of input values: "
                   << theInputVars.size() << " != " << fNvars << std::endl;
         fStatusIsClean = false;
      }

      // validate input variables
      for (size_t ivar = 0; ivar < theInputVars.size(); ivar++) {
         if (theInputVars[ivar] != inputVars[ivar]) {
            std::cout << "Problem in class \"" << fClassName << "\": mismatch in input variable names" << std::endl
                      << " for variable [" << ivar << "]: " << theInputVars[ivar].c_str() << " != " << inputVars[ivar] << std::endl;
            fStatusIsClean = false;
         }
      }

      // initialize min and max vectors (for normalisation)
      fVmin[0] = 0;
      fVmax[0] = 0;
      fVmin[1] = 0;
      fVmax[1] = 0;
      fVmin[2] = 0;
      fVmax[2] = 0;
      fVmin[3] = 0;
      fVmax[3] = 0;

      // initialize input variable types
      fType[0] = 'F';
      fType[1] = 'F';
      fType[2] = 'F';
      fType[3] = 'F';

      // initialize constants
      Initialize();

   }

   // destructor
   virtual ~ReadRuleFit() {
      Clear(); // method-specific
   }

   // the classifier response
   // "inputValues" is a vector of input values in the same order as the 
   // variables given to the constructor
   double GetMvaValue( const std::vector<double>& inputValues ) const;

 private:

   // method-specific destructor
   void Clear();

   // common member variables
   const char* fClassName;

   const size_t fNvars;
   size_t GetNvar()           const { return fNvars; }
   char   GetType( int ivar ) const { return fType[ivar]; }

   // normalisation of input variables
   const bool fIsNormalised;
   bool IsNormalised() const { return fIsNormalised; }
   double fVmin[4];
   double fVmax[4];
   double NormVariable( double x, double xmin, double xmax ) const {
      // normalise to output range: [-1, 1]
      return 2*(x - xmin)/(xmax - xmin) - 1.0;
   }

   // type of input variable: 'F' or 'I'
   char   fType[4];

   // initialize internal variables
   void Initialize();
   double GetMvaValue__( const std::vector<double>& inputValues ) const;

   // private members (method specific)
   // not implemented for class: "ReadRuleFit"
};
void   ReadRuleFit::Initialize(){}
void   ReadRuleFit::Clear(){}
double ReadRuleFit::GetMvaValue__( const std::vector<double>& inputValues ) const {
   double rval=1.821665671;
   //
   // here follows all rules ordered in importance (most important first)
   // at the end of each line, the relative importance of the rule is given
   //
   if ((inputValues[2]<0.2859873176)&&(inputValues[3]<-0.6145658493)) rval+=-0.5383069125;   // importance = 0.523
   if ((0.6637439728<inputValues[0])&&(inputValues[3]<1.852592468)) rval+=-0.365472615;   // importance = 0.354
   if ((-0.8042526245<inputValues[0])) rval+=-0.3487120504;   // importance = 0.352
   if ((inputValues[2]<0.2859873176)&&(-0.6145658493<inputValues[3])) rval+=0.3265835596;   // importance = 0.325
   if ((inputValues[0]<1.397742271)&&(-0.7250279784<inputValues[1])&&(inputValues[3]<-0.6721984744)) rval+=-0.3591921639;   // importance = 0.310
   if ((inputValues[0]<2.865738869)&&(inputValues[3]<1.206904054)) rval+=-0.3235634573;   // importance = 0.283
   if ((inputValues[3]<1.110067248)) rval+=-0.3014417789;   // importance = 0.274
   if ((inputValues[0]<1.361399651)&&(inputValues[1]<0.2200206369)&&(inputValues[3]<-0.411757946)) rval+=-0.2635351483;   // importance = 0.227
   if ((0.2200206369<inputValues[1])) rval+=-0.199620194;   // importance = 0.213
   if ((-0.07025432587<inputValues[0])&&(0.3575037718<inputValues[1])) rval+=-0.2338918124;   // importance = 0.199
   if ((inputValues[2]<-1.044834495)) rval+=-0.2463489969;   // importance = 0.195
   if ((-1.538250923<inputValues[0])&&(inputValues[0]<1.266595125)&&(inputValues[3]<0.3321121633)) rval+=-0.1879163686;   // importance = 0.195
   if ((inputValues[1]<0.07876376063)&&(inputValues[3]<0.1014136598)) rval+=-0.2062533705;   // importance = 0.194
   if ((-0.6012272835<inputValues[2])&&(0.9022580981<inputValues[3])) rval+=0.1703085413;   // importance = 0.165
   if ((inputValues[1]<0.2200206369)) rval+=-0.1519403671;   // importance = 0.162
   if ((-0.4926698804<inputValues[2])&&(inputValues[3]<0.3393571973)) rval+=-0.1698124189;   // importance = 0.160
   if ((inputValues[0]<1.361399651)&&(inputValues[1]<0.2200206369)) rval+=0.1412135028;   // importance = 0.151
   if ((-0.737119019<inputValues[1])&&(inputValues[1]<0.02489273809)&&(inputValues[3]<0.605740428)) rval+=-0.1831062971;   // importance = 0.149
   if ((inputValues[0]<2.487332582)&&(-0.4926698804<inputValues[2])&&(inputValues[3]<1.069083929)) rval+=-0.1373525789;   // importance = 0.147
   if ((0.2200206369<inputValues[1])&&(inputValues[3]<0.7960036993)) rval+=-0.1430605103;   // importance = 0.141
   if ((0.2200206369<inputValues[1])&&(-1.044834495<inputValues[2])&&(inputValues[3]<0.196363762)) rval+=-0.1744597681;   // importance = 0.133
   if ((0.07876376063<inputValues[1])&&(0.2859873176<inputValues[2])) rval+=-0.1581814857;   // importance = 0.131
   if ((-1.856152892<inputValues[0])&&(inputValues[0]<0.6637439728)&&(0.2456704378<inputValues[3])) rval+=0.1660814983;   // importance = 0.123
   if ((inputValues[0]<-0.3903895915)&&(-0.1605666727<inputValues[1])&&(inputValues[2]<1.173201919)) rval+=0.1320495424;   // importance = 0.118
   if ((-0.876881063<inputValues[0])&&(inputValues[1]<-0.1346641928)&&(0.605740428<inputValues[3])) rval+=0.1373748234;   // importance = 0.110
   if ((inputValues[0]<2.865738869)&&(1.206904054<inputValues[3])) rval+=0.1301838684;   // importance = 0.102
   if ((inputValues[0]<2.865738869)) rval+=-0.1921057245;   // importance = 0.092
   if ((inputValues[0]<0.6637439728)&&(-0.237038821<inputValues[1])&&(0.2456704378<inputValues[3])) rval+=0.1434630503;   // importance = 0.087
   if ((-0.07025432587<inputValues[0])&&(inputValues[1]<0.3575037718)) rval+=-0.08493248301;   // importance = 0.086
   if ((-1.044834495<inputValues[2])) rval+=-0.1051437122;   // importance = 0.083
   if ((0.02489273809<inputValues[1])&&(inputValues[2]<0.7852135301)&&(inputValues[3]<0.605740428)) rval+=-0.08363995833;   // importance = 0.082
   if ((-0.3790929615<inputValues[0])&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])&&(inputValues[3]<1.066591382)) rval+=-0.09249249872;   // importance = 0.079
   if ((inputValues[0]<-0.3790929615)&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])) rval+=0.09272184004;   // importance = 0.071
   if ((0.2200206369<inputValues[1])&&(inputValues[1]<0.774100244)&&(-1.044834495<inputValues[2])&&(inputValues[3]<0.196363762)) rval+=-0.1208843459;   // importance = 0.069
   if ((-0.3790929615<inputValues[0])&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])&&(inputValues[2]<1.375104785)&&(inputValues[3]<1.066591382)) rval+=-0.07764621172;   // importance = 0.066
   if ((-0.3903895915<inputValues[0])&&(-0.1605666727<inputValues[1])&&(inputValues[2]<1.173201919)) rval+=-0.0690361005;   // importance = 0.066
   if ((0.6637439728<inputValues[0])&&(1.386405587<inputValues[3])) rval+=-0.08141573768;   // importance = 0.065
   if ((-0.3790929615<inputValues[0])&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])) rval+=-0.06193442764;   // importance = 0.063
   if ((inputValues[0]<1.397742271)&&(-0.7250279784<inputValues[1])) rval+=0.05855968621;   // importance = 0.062
   if ((-0.4885016978<inputValues[0])&&(-1.044834495<inputValues[2])&&(1.261463404<inputValues[3])) rval+=-0.07066745959;   // importance = 0.061
   if ((-0.5954368114<inputValues[1])&&(inputValues[2]<-0.6012272835)) rval+=-0.06641189659;   // importance = 0.058
   if ((-0.876881063<inputValues[0])&&(-0.1346641928<inputValues[1])&&(0.605740428<inputValues[3])) rval+=-0.0589214863;   // importance = 0.051
   if ((-0.5954368114<inputValues[1])&&(inputValues[1]<-0.06197149307)&&(inputValues[2]<0.2926391363)) rval+=-0.05675071978;   // importance = 0.039
   if ((0.2200206369<inputValues[1])&&(0.7960036993<inputValues[3])) rval+=-0.05407344724;   // importance = 0.039
   if ((inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])) rval+=0.03043669572;   // importance = 0.033
   if ((0.2200206369<inputValues[1])&&(-1.044834495<inputValues[2])&&(0.196363762<inputValues[3])) rval+=0.03522315626;   // importance = 0.031
   if ((-0.3790929615<inputValues[0])&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])&&(1.066591382<inputValues[3])) rval+=0.03174133575;   // importance = 0.024
   if ((-1.810295105<inputValues[2])&&(inputValues[2]<-1.044834495)) rval+=-0.02586694411;   // importance = 0.017
   if ((inputValues[0]<0.6637439728)&&(inputValues[1]<-0.237038821)&&(0.2456704378<inputValues[3])) rval+=0.02297392817;   // importance = 0.011
   if ((-1.411566615<inputValues[3])) rval+=-0.01612698015;   // importance = 0.011
   if ((inputValues[1]<-0.1605666727)&&(inputValues[2]<1.173201919)) rval+=-0.008633417105;   // importance = 0.009
   if ((-0.3790929615<inputValues[0])&&(inputValues[1]<0.2200206369)&&(-1.044834495<inputValues[2])&&(inputValues[2]<0.340533644)&&(1.066591382<inputValues[3])) rval+=0.02724536541;   // importance = 0.005
   //
   // here follows all linear terms
   // at the end of each line, the relative importance of the term is given
   //
   rval+=-0.230579859*std::min( double(3.424694538), std::max( double(inputValues[0]), double(-3.440958977)));   // importance = 0.902
   rval+=-0.03918419635*std::min( double(2.07433629), std::max( double(inputValues[1]), double(-2.206938982)));   // importance = 0.096
   rval+=0.007237378388*std::min( double(2.088175535), std::max( double(inputValues[2]), double(-2.172396898)));   // importance = 0.017
   rval+=0.3519137031*std::min( double(2.604138613), std::max( double(inputValues[3]), double(-2.361749649)));   // importance = 1.000
   return rval;
}
   inline double ReadRuleFit::GetMvaValue( const std::vector<double>& inputValues ) const
   {
      // classifier response value
      double retval = 0;

      // classifier response, sanity check first
      if (!IsStatusClean()) {
         std::cout << "Problem in class \"" << fClassName << "\": cannot return classifier response"
                   << " because status is dirty" << std::endl;
         retval = 0;
      }
      else {
         if (IsNormalised()) {
            // normalise variables
            std::vector<double> iV;
            iV.reserve(inputValues.size());
            int ivar = 0;
            for (std::vector<double>::const_iterator varIt = inputValues.begin();
                 varIt != inputValues.end(); varIt++, ivar++) {
               iV.push_back(NormVariable( *varIt, fVmin[ivar], fVmax[ivar] ));
            }
            retval = GetMvaValue__( iV );
         }
         else {
            retval = GetMvaValue__( inputValues );
         }
      }

      return retval;
   }