DoTraining.C

Go to the documentation of this file.

#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include "TChain.h"
#include "TFile.h"
#include "TTree.h"
#include "TString.h"
#include "TObjString.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TMVA/MethodCategory.h"
#include "TMVA/Factory.h"
#include "TMVA/DataLoader.h"
#include "TMVA/Tools.h"
#include "TMVA/TMVAGui.h"

void DoTraining(){

  // ------------------------------------------------
  // stuff that requires user input is up front
  // ------------------------------------------------

  // get signal and background trees from input file
  TFile* inFile     = new TFile("./TrainingTrees.root");
  TTree* ncTree     = (TTree*)inFile->Get("ncTree");
  TTree* cosmicTree = (TTree*)inFile->Get("cosTree");

  // define weights for nc and cosmic events, i.e.
  // weight these to the same POT/livetime
  double ncWeight     = 0.000136814;
  double cosmicWeight = 0.010794024;

  TCut signalCuts     = ""; // for example: TCut mycuts = "abs(var1)<0.5 && abs(var2-0.5)<1";
  TCut backgroundCuts = ""; // for example: TCut mycutb = "abs(var1)<0.5";

  // create output file
  TFile* outFile = new TFile("outFile.root", "recreate");

  // setup factory options
  // -- V               : verbose             
  // -- Silent          : suppress all output 
  // -- Transformations : list of transformations to check:
  //                      identity,
  //                      decorreation
  //                      PCA,
  //                      gaussianisation followed by decorrelation,
  // -- AnalysisType    : classification or regression
  //
  // for additional information on Transformations see Section 4.1 
  // of the TMVA Users' Guide: https://root.cern.ch/download/doc/tmva/TMVAUsersGuide.pdf

  std::string factoryRunOpt   = "V:!Silent";
  // there are issues with the decorrelated varibles so
  // neglect those options for now
  //std::string transformations = "I;D;P;G,D" ;
  std::string transformations = "I;P";
  std::string analysisType    = "Classification";

  std::string factoryOptions = factoryRunOpt       +
                               ":Transformations=" + transformations +
                               ":AnalysisType="    + analysisType;

  // setup sample preparation options
  // -- V                : verbose            
  // -- nTrainSignal     : number of signal events for training
  // -- nTrainBackground : number of background events for training
  // -- splitMode        : defines how the training and test samples
  //                       are selected from the source trees
  // -- normMode         : renormalisation of events

  std::string prepRunOpt       = "V";
  std::string nTrainSignal     = "0";
  std::string nTrainBackground = "0";
  std::string splitMode        = "Random";
 // std::string normMode         = "NumEvents";
  std::string normMode         = "None";


  std::string prepOptions = prepRunOpt +
                            ":nTrain_Signal="     + nTrainSignal     +
                            ":nTrain_Background=" + nTrainBackground +
                            ":SplitMode="         + splitMode        +
                            ":NormMode="          + normMode;

  // setup sample preparation options
  // -- V                      : verbose            
  // -- H                      : print help information
  // -- InverseBoostNegWeights : treatment of events with negative
  //                             weights
  // -- nTrees                 : number of trees in the training forest
  // -- boostType              : boosting type for the trees in the forest
  //                             (options are AdaBoost, RealAdaBoost, 
  //                             Bagging, AdBoostR2, Grad)
  // -- shrinkage              : learning rate for GradBoost algorithm
  // -- nCuts                  : number of grid points in variable range
  //                             used in finding optimal cut in node splitting
  // -- maxDepth               : max depth of decision trees allowed
  // -- minNodeSize            : minimum percentage of training events 
  //                             required in a leaf node
  // -- node purity limit      : in boosting/pruning, nodes with purity
  //                             > than this value are signal, otherwise
  //                             background

  std::string bookRunOpt      = "V:!H:InverseBoostNegWeights";
  std::string nTrees          = "1000";
  std::string shrinkage       = "0.1";
  std::string nCuts           = "30";
  std::string maxDepth        = "5";
  std::string minNodeSize     = "2%";
  std::string nodePurityLimit = "0.9";
  std::vector<std::string> boostTypes = 
  {"Grad",
   "RealAdaBoost"};
   //"AdaBoost",
   //"Bagging"};

  // -----------------------------------------------
  // don't change stuff below here without knowing
  // what you're doing
  // -----------------------------------------------

  // load TMVA libraries
  TMVA::Tools::Instance();

  TMVA::Factory *factory = new TMVA::Factory("TMVAClassifier", 
      outFile, 
      factoryOptions );

  // setup TMVA::DataLoader, and add training/spectator variables
  TMVA::DataLoader* dataLoader = new TMVA::DataLoader("dataLoader");

  dataLoader->AddVariable("vtxx"                , 'F');
  dataLoader->AddVariable("vtxy"                , 'F');
  dataLoader->AddVariable("vtxz"                , 'F');
  dataLoader->AddVariable("closestslicemindist" , 'F');
  dataLoader->AddVariable("ncontplanes"         , 'I');
  dataLoader->AddVariable("shwhitx"             , 'I');
  dataLoader->AddVariable("shwhity"             , 'I');
  dataLoader->AddVariable("shwhittot"           , 'I');
  dataLoader->AddVariable("shwhitasymm"         , 'I');
  dataLoader->AddVariable("shwhitratio"         , 'F');
  dataLoader->AddVariable("nshowers"            , 'I');
  dataLoader->AddVariable("showerwidth"         , 'F');
  dataLoader->AddVariable("showerlength"        , 'F');
  dataLoader->AddVariable("showerdirycosine"    , 'F');
  dataLoader->AddVariable("showergap"           , 'F');
  dataLoader->AddVariable("showercale"          , 'F');
  dataLoader->AddVariable("nhitsperplane"       , 'F');
  dataLoader->AddVariable("nmiphits"            , 'I');
  dataLoader->AddVariable("nhitsperslice"       , 'F');
  dataLoader->AddVariable("partptp"             , 'F');
  dataLoader->AddVariable("closestslicetime"    , 'F');

  dataLoader->AddSpectator("run"    , 'I');
  dataLoader->AddSpectator("subrun" , 'I');
  dataLoader->AddSpectator("evt"    , 'I');
  dataLoader->AddSpectator("subevt" , 'S');

  // add signal and background tree
  dataLoader->AddSignalTree    (ncTree    , ncWeight    );
  dataLoader->AddBackgroundTree(cosmicTree, cosmicWeight);

  // prepare trees
  dataLoader->PrepareTrainingAndTestTree(signalCuts, backgroundCuts, prepOptions);

  for (size_t i = 0; i < boostTypes.size(); ++i){ 

    std::string bookOptions = bookRunOpt           +
                              ":NTrees="           + nTrees           +
                              ":BoostType="        + boostTypes.at(i) +
                              ":Shrinkage="        + shrinkage        +
                              ":nCuts="            + nCuts            +
                              ":MaxDepth="         + maxDepth         +
                              ":MinNodeSize="      + minNodeSize      +
                              ":NodePurityLimit= " + nodePurityLimit;

    factory->BookMethod(dataLoader, TMVA::Types::kBDT, "BDTA"+boostTypes.at(i), bookOptions);
  }

  factory->TrainAllMethods();
  factory->TestAllMethods();
  factory->EvaluateAllMethods();

  outFile->Close();

  delete factory;

  if (!gROOT->IsBatch()) TMVA::TMVAGui( outFile->GetName() );

}