doc/v636/TMVAMulticlass_8C.html

#include <cstdlib>

#include <iostream>

#include <map>

#include <string>


#include "TFile.h"

#include "TTree.h"

#include "TString.h"

#include "TSystem.h"

#include "TROOT.h"


#include "TMVA/Tools.h"

#include "TMVA/Factory.h"

#include "TMVA/DataLoader.h"

#include "TMVA/TMVAMultiClassGui.h"


using namespace TMVA;


void TMVAMulticlass( TString myMethodList = "" )

{


   // This loads the library

   TMVA::Tools::Instance();


   // to get access to the GUI and all tmva macros

   //

   //     TString tmva_dir(TString(gRootDir) + "/tmva");

   //     if(gSystem->Getenv("TMVASYS"))

   //        tmva_dir = TString(gSystem->Getenv("TMVASYS"));

   //     gROOT->SetMacroPath(tmva_dir + "/test/:" + gROOT->GetMacroPath() );

   //     gROOT->ProcessLine(".L TMVAMultiClassGui.C");


   //---------------------------------------------------------------

   // Default MVA methods to be trained + tested

   std::map<std::string,int> Use;

   Use["MLP"]             = 1;

   Use["BDTG"]            = 1;

#ifdef R__HAS_TMVAGPU

   Use["DL_CPU"]          = 1;

   Use["DL_GPU"]          = 1;

#else

   Use["DL_CPU"]          = 1;

   Use["DL_GPU"]          = 0;

#endif

   Use["FDA_GA"]          = 0;

   Use["PDEFoam"]         = 1;


   //---------------------------------------------------------------


   std::cout << std::endl;

   std::cout << "==> Start TMVAMulticlass" << std::endl;


   if (myMethodList != "") {

      for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;


      std::vector<TString> mlist = TMVA::gTools().SplitString( myMethodList, ',' );

      for (UInt_t i=0; i<mlist.size(); i++) {

         std::string regMethod(mlist[i]);


         if (Use.find(regMethod) == Use.end()) {

            std::cout << "Method \"" << regMethod << "\" not known in TMVA under this name. Choose among the following:" << std::endl;

            for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) std::cout << it->first << " ";

            std::cout << std::endl;

            return;

         }

         Use[regMethod] = 1;

      }

   }


   // Create a new root output file.

   TString outfileName = "TMVAMulticlass.root";

   TFile* outputFile = TFile::Open( outfileName, "RECREATE" );


   TMVA::Factory *factory = new TMVA::Factory( "TMVAMulticlass", outputFile,

                                               "!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=multiclass" );

   TMVA::DataLoader *dataloader=new TMVA::DataLoader("dataset");


   dataloader->AddVariable( "var1", 'F' );

   dataloader->AddVariable( "var2", "Variable 2", "", 'F' );

   dataloader->AddVariable( "var3", "Variable 3", "units", 'F' );

   dataloader->AddVariable( "var4", "Variable 4", "units", 'F' );


   TFile *input(nullptr);

   TString fname = gROOT->GetTutorialDir() + "/machine_learning/data/tmva_multiclass_example.root";

   if (!gSystem->AccessPathName( fname )) {

      input = TFile::Open( fname ); // check if file in local directory exists

   }

   if (!input) {

      std::cout << "ERROR: could not open data file" << std::endl;

      exit(1);

   }

   std::cout << "--- TMVAMulticlass: Using input file: " << input->GetName() << std::endl;


   TTree *signalTree  = (TTree*)input->Get("TreeS");

   TTree *background0 = (TTree*)input->Get("TreeB0");

   TTree *background1 = (TTree*)input->Get("TreeB1");

   TTree *background2 = (TTree*)input->Get("TreeB2");


   gROOT->cd( outfileName+TString(":/") );

   dataloader->AddTree    (signalTree,"Signal");

   dataloader->AddTree    (background0,"bg0");

   dataloader->AddTree    (background1,"bg1");

   dataloader->AddTree    (background2,"bg2");


   dataloader->PrepareTrainingAndTestTree( "", "SplitMode=Random:NormMode=NumEvents:!V" );


   if (Use["BDTG"]) // gradient boosted decision trees

      factory->BookMethod( dataloader,  TMVA::Types::kBDT, "BDTG", "!H:!V:NTrees=1000:BoostType=Grad:Shrinkage=0.10:UseBaggedBoost:BaggedSampleFraction=0.50:nCuts=20:MaxDepth=2");

   if (Use["MLP"]) // neural network

      factory->BookMethod( dataloader,  TMVA::Types::kMLP, "MLP", "!H:!V:NeuronType=tanh:NCycles=1000:HiddenLayers=N+5,5:TestRate=5:EstimatorType=MSE");

   if (Use["FDA_GA"]) // functional discriminant with GA minimizer

      factory->BookMethod( dataloader,  TMVA::Types::kFDA, "FDA_GA", "H:!V:Formula=(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3:ParRanges=(-1,1);(-10,10);(-10,10);(-10,10);(-10,10):FitMethod=GA:PopSize=300:Cycles=3:Steps=20:Trim=True:SaveBestGen=1" );

   if (Use["PDEFoam"]) // PDE-Foam approach

      factory->BookMethod( dataloader,  TMVA::Types::kPDEFoam, "PDEFoam", "!H:!V:TailCut=0.001:VolFrac=0.0666:nActiveCells=500:nSampl=2000:nBin=5:Nmin=100:Kernel=None:Compress=T" );


   if (Use["DL_CPU"]) {

      TString layoutString("Layout=TANH|100,TANH|50,TANH|10,LINEAR");

      TString trainingStrategyString("TrainingStrategy=Optimizer=ADAM,LearningRate=1e-3,"

                                     "TestRepetitions=1,ConvergenceSteps=10,BatchSize=100,MaxEpochs=20");

      TString nnOptions("!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:"

                        "WeightInitialization=XAVIERUNIFORM:Architecture=GPU");

      nnOptions.Append(":");

      nnOptions.Append(layoutString);

      nnOptions.Append(":");

      nnOptions.Append(trainingStrategyString);

      factory->BookMethod(dataloader, TMVA::Types::kDL, "DL_CPU", nnOptions);

   }

   if (Use["DL_GPU"]) {

      TString layoutString("Layout=TANH|100,TANH|50,TANH|10,LINEAR");

      TString trainingStrategyString("TrainingStrategy=Optimizer=ADAM,LearningRate=1e-3,"

                                     "TestRepetitions=1,ConvergenceSteps=10,BatchSize=100,MaxEpochs=20");

      TString nnOptions("!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:"

                        "WeightInitialization=XAVIERUNIFORM:Architecture=GPU");

      nnOptions.Append(":");

      nnOptions.Append(layoutString);

      nnOptions.Append(":");

      nnOptions.Append(trainingStrategyString);

      factory->BookMethod(dataloader, TMVA::Types::kDL, "DL_GPU", nnOptions);

   }


   // Train MVAs using the set of training events

   factory->TrainAllMethods();


   // Evaluate all MVAs using the set of test events

   factory->TestAllMethods();


   // Evaluate and compare performance of all configured MVAs

   factory->EvaluateAllMethods();


   // --------------------------------------------------------------


   // Save the output

   outputFile->Close();


   std::cout << "==> Wrote root file: " << outputFile->GetName() << std::endl;

   std::cout << "==> TMVAMulticlass is done!" << std::endl;


   delete factory;

   delete dataloader;


   // Launch the GUI for the root macros

   if (!gROOT->IsBatch()) TMVAMultiClassGui( outfileName );


}


int main( int argc, char** argv )

{

   // Select methods (don't look at this code - not of interest)

   TString methodList;

   for (int i=1; i<argc; i++) {

      TString regMethod(argv[i]);

      if(regMethod=="-b" || regMethod=="--batch") continue;

      if (!methodList.IsNull()) methodList += TString(",");

      methodList += regMethod;

   }

   TMVAMulticlass(methodList);

   return 0;

}


DataLoader.h

main
int main()
Definition Prototype.cxx:12

UInt_t
unsigned int UInt_t
Definition RtypesCore.h:46

TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358

TFile.h

input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Definition TGWin32VirtualXProxy.cxx:142

TMVAMultiClassGui.h

TROOT.h

gROOT
#define gROOT
Definition TROOT.h:414

TString.h

TSystem.h

gSystem
R__EXTERN TSystem * gSystem
Definition TSystem.h:572

TTree.h

Tools.h

ROOT::Detail::TRangeCast
Definition TCollection.h:311

TFile
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131

TFile::Open
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition TFile.cxx:4131

TMVA::DataLoader
Definition DataLoader.h:50

TMVA::Factory
This is the main MVA steering class.
Definition Factory.h:80

TMVA::Factory::TrainAllMethods
void TrainAllMethods()
Iterates through all booked methods and calls training.
Definition Factory.cxx:1114

TMVA::Factory::BookMethod
MethodBase * BookMethod(DataLoader *loader, TString theMethodName, TString methodTitle, TString theOption="")
Book a classifier or regression method.
Definition Factory.cxx:352

TMVA::Factory::TestAllMethods
void TestAllMethods()
Evaluates all booked methods on the testing data and adds the output to the Results in the corresponi...
Definition Factory.cxx:1271

TMVA::Factory::EvaluateAllMethods
void EvaluateAllMethods(void)
Iterates over all MVAs that have been booked, and calls their evaluation methods.
Definition Factory.cxx:1376

TMVA::Tools::Instance
static Tools & Instance()
Definition Tools.cxx:71

TMVA::Tools::SplitString
std::vector< TString > SplitString(const TString &theOpt, const char separator) const
splits the option string at 'separator' and fills the list 'splitV' with the primitive strings
Definition Tools.cxx:1199

TMVA::Types::kFDA
@ kFDA
Definition Types.h:92

TMVA::Types::kBDT
@ kBDT
Definition Types.h:86

TMVA::Types::kDL
@ kDL
Definition Types.h:99

TMVA::Types::kPDEFoam
@ kPDEFoam
Definition Types.h:94

TMVA::Types::kMLP
@ kMLP
Definition Types.h:90

TString
Basic string class.
Definition TString.h:139

TSystem::AccessPathName
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1308

TTree
A TTree represents a columnar dataset.
Definition TTree.h:84

TMVA
create variable transformations
Definition GeneticMinimizer.h:22

TMVA::gTools
Tools & gTools()

TMVA::TMVAMultiClassGui
void TMVAMultiClassGui(const char *fName="TMVAMulticlass.root", TString dataset="")

Factory.h