Logo ROOT  
Reference Guide
MethodBase.h
Go to the documentation of this file.
1// @(#)root/tmva $Id$
2// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard von Toerne, Jan Therhaag
3
4/**********************************************************************************
5 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6 * Package: TMVA *
7 * Class : MethodBase *
8 * Web : http://tmva.sourceforge.net *
9 * *
10 * Description: *
11 * Virtual base class for all MVA method *
12 * *
13 * Authors (alphabetical): *
14 * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
15 * Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
16 * Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *
17 * Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany *
18 * Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany *
19 * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany *
20 * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
21 * *
22 * Copyright (c) 2005-2011: *
23 * CERN, Switzerland *
24 * U. of Victoria, Canada *
25 * MPI-K Heidelberg, Germany *
26 * U. of Bonn, Germany *
27 * *
28 * Redistribution and use in source and binary forms, with or without *
29 * modification, are permitted according to the terms listed in LICENSE *
30 * (http://tmva.sourceforge.net/LICENSE) *
31 **********************************************************************************/
32
33#ifndef ROOT_TMVA_MethodBase
34#define ROOT_TMVA_MethodBase
35
36//////////////////////////////////////////////////////////////////////////
37// //
38// MethodBase //
39// //
40// Virtual base class for all TMVA method //
41// //
42//////////////////////////////////////////////////////////////////////////
43
44#include <iosfwd>
45#include <vector>
46#include <map>
47#include "assert.h"
48
49#include "TString.h"
50
51#include "TMVA/IMethod.h"
52#include "TMVA/Configurable.h"
53#include "TMVA/Types.h"
54#include "TMVA/DataSet.h"
55#include "TMVA/Event.h"
57#include <TMVA/Results.h>
59
60#include <TFile.h>
61
62class TGraph;
63class TTree;
64class TDirectory;
65class TSpline;
66class TH1F;
67class TH1D;
68class TMultiGraph;
69
70/*! \class TMVA::IPythonInteractive
71\ingroup TMVA
72
73This class is needed by JsMVA, and it's a helper class for tracking errors during
74the training in Jupyter notebook. It’s only initialized in Jupyter notebook context.
75In initialization we specify some title, and a TGraph will be created for every title.
76We can add new data points easily to all TGraphs. These graphs are added to a
77TMultiGraph, and during an interactive training we get this TMultiGraph object
78and plot it with JsROOT.
79*/
80
81namespace TMVA {
82
83 class Ranking;
84 class PDF;
85 class TSpline1;
86 class MethodCuts;
87 class MethodBoost;
88 class DataSetInfo;
89 namespace Experimental {
90 class Classification;
91 }
92 class TrainingHistory;
93
95 public:
98 void Init(std::vector<TString>& graphTitles);
99 void ClearGraphs();
100 void AddPoint(Double_t x, Double_t y1, Double_t y2);
101 void AddPoint(std::vector<Double_t>& dat);
102 inline TMultiGraph* Get() {return fMultiGraph;}
103 inline bool NotInitialized(){ return fNumGraphs==0;};
104 private:
106 std::vector<TGraph*> fGraphs;
109 };
110
111 class MethodBase : virtual public IMethod, public Configurable {
112
113 friend class CrossValidation;
114 friend class Factory;
115 friend class RootFinder;
116 friend class MethodBoost;
119
120 public:
121
123
124 // default constructor
125 MethodBase( const TString& jobName,
126 Types::EMVA methodType,
127 const TString& methodTitle,
128 DataSetInfo& dsi,
129 const TString& theOption = "" );
130
131 // constructor used for Testing + Application of the MVA, only (no training),
132 // using given weight file
133 MethodBase( Types::EMVA methodType,
134 DataSetInfo& dsi,
135 const TString& weightFile );
136
137 // default destructor
138 virtual ~MethodBase();
139
140 // declaration, processing and checking of configuration options
141 void SetupMethod();
142 void ProcessSetup();
143 virtual void CheckSetup(); // may be overwritten by derived classes
144
145 // ---------- main training and testing methods ------------------------------
146
147 // prepare tree branch with the method's discriminating variable
149
150 // performs classifier training
151 // calls methods Train() implemented by derived classes
152 void TrainMethod();
153
154 // optimize tuning parameters
155 virtual std::map<TString,Double_t> OptimizeTuningParameters(TString fomType="ROCIntegral", TString fitType="FitGA");
156 virtual void SetTuneParameters(std::map<TString,Double_t> tuneParameters);
157
158 virtual void Train() = 0;
159
160 // store and retrieve time used for training
161 void SetTrainTime( Double_t trainTime ) { fTrainTime = trainTime; }
162 Double_t GetTrainTime() const { return fTrainTime; }
163
164 // store and retrieve time used for testing
165 void SetTestTime ( Double_t testTime ) { fTestTime = testTime; }
166 Double_t GetTestTime () const { return fTestTime; }
167
168 // performs classifier testing
169 virtual void TestClassification();
170 virtual Double_t GetKSTrainingVsTest(Char_t SorB, TString opt="X");
171
172 // performs multiclass classifier testing
173 virtual void TestMulticlass();
174
175 // performs regression testing
176 virtual void TestRegression( Double_t& bias, Double_t& biasT,
177 Double_t& dev, Double_t& devT,
178 Double_t& rms, Double_t& rmsT,
179 Double_t& mInf, Double_t& mInfT, // mutual information
180 Double_t& corr,
182
183 // options treatment
184 virtual void Init() = 0;
185 virtual void DeclareOptions() = 0;
186 virtual void ProcessOptions() = 0;
187 virtual void DeclareCompatibilityOptions(); // declaration of past options
188
189 // reset the Method --> As if it was not yet trained, just instantiated
190 // virtual void Reset() = 0;
191 //for the moment, I provide a dummy (that would not work) default, just to make
192 // compilation/running w/o parameter optimisation still possible
193 virtual void Reset(){return;}
194
195 // classifier response:
196 // some methods may return a per-event error estimate
197 // error calculation is skipped if err==0
198 virtual Double_t GetMvaValue( Double_t* errLower = 0, Double_t* errUpper = 0) = 0;
199
200 // signal/background classification response
201 Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0, Double_t* errUpper = 0 );
202
203 protected:
204 // helper function to set errors to -1
205 void NoErrorCalc(Double_t* const err, Double_t* const errUpper);
206
207 // signal/background classification response for all current set of data
208 virtual std::vector<Double_t> GetMvaValues(Long64_t firstEvt = 0, Long64_t lastEvt = -1, Bool_t logProgress = false);
209 // same as above but using a provided data set (used by MethodCategory)
210 virtual std::vector<Double_t> GetDataMvaValues(DataSet *data = nullptr, Long64_t firstEvt = 0, Long64_t lastEvt = -1, Bool_t logProgress = false);
211
212 public:
213 // regression response
214 const std::vector<Float_t>& GetRegressionValues(const TMVA::Event* const ev){
215 fTmpEvent = ev;
216 const std::vector<Float_t>* ptr = &GetRegressionValues();
217 fTmpEvent = 0;
218 return (*ptr);
219 }
220
221 virtual const std::vector<Float_t>& GetRegressionValues() {
222 std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
223 return (*ptr);
224 }
225
226 // multiclass classification response
227 virtual const std::vector<Float_t>& GetMulticlassValues() {
228 std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
229 return (*ptr);
230 }
231
232 // Training history
233 virtual const std::vector<Float_t>& GetTrainingHistory(const char* /*name*/ ) {
234 std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
235 return (*ptr);
236 }
237
238 // probability of classifier response (mvaval) to be signal (requires "CreateMvaPdf" option set)
239 virtual Double_t GetProba( const Event *ev); // the simple one, automatically calculates the mvaVal and uses the SAME sig/bkg ratio as given in the training sample (typically 50/50 .. (NormMode=EqualNumEvents) but can be different)
240 virtual Double_t GetProba( Double_t mvaVal, Double_t ap_sig );
241
242 // Rarity of classifier response (signal or background (default) is uniform in [0,1])
243 virtual Double_t GetRarity( Double_t mvaVal, Types::ESBType reftype = Types::kBackground ) const;
244
245 // create ranking
246 virtual const Ranking* CreateRanking() = 0;
247
248 // make ROOT-independent C++ class
249 virtual void MakeClass( const TString& classFileName = TString("") ) const;
250
251 // print help message
252 void PrintHelpMessage() const;
253
254 //
255 // streamer methods for training information (creates "weight" files) --------
256 //
257 public:
258 void WriteStateToFile () const;
259 void ReadStateFromFile ();
260
261 protected:
262 // the actual "weights"
263 virtual void AddWeightsXMLTo ( void* parent ) const = 0;
264 virtual void ReadWeightsFromXML ( void* wghtnode ) = 0;
265 virtual void ReadWeightsFromStream( std::istream& ) = 0; // backward compatibility
266 virtual void ReadWeightsFromStream( TFile& ) {} // backward compatibility
267
268 private:
269 friend class MethodCategory;
271 void WriteStateToXML ( void* parent ) const;
272 void ReadStateFromXML ( void* parent );
273 void WriteStateToStream ( std::ostream& tf ) const; // needed for MakeClass
274 void WriteVarsToStream ( std::ostream& tf, const TString& prefix = "" ) const; // needed for MakeClass
275
276
277 public: // these two need to be public, they are used to read in-memory weight-files
278 void ReadStateFromStream ( std::istream& tf ); // backward compatibility
279 void ReadStateFromStream ( TFile& rf ); // backward compatibility
280 void ReadStateFromXMLString( const char* xmlstr ); // for reading from memory
281
282 private:
283 // the variable information
284 void AddVarsXMLTo ( void* parent ) const;
285 void AddSpectatorsXMLTo ( void* parent ) const;
286 void AddTargetsXMLTo ( void* parent ) const;
287 void AddClassesXMLTo ( void* parent ) const;
288 void ReadVariablesFromXML ( void* varnode );
289 void ReadSpectatorsFromXML( void* specnode);
290 void ReadTargetsFromXML ( void* tarnode );
291 void ReadClassesFromXML ( void* clsnode );
292 void ReadVarsFromStream ( std::istream& istr ); // backward compatibility
293
294 public:
295 // ---------------------------------------------------------------------------
296
297 // write evaluation histograms into target file
298 virtual void WriteEvaluationHistosToFile(Types::ETreeType treetype);
299
300 // write classifier-specific monitoring information to target file
301 virtual void WriteMonitoringHistosToFile() const;
302
303 // ---------- public evaluation methods --------------------------------------
304
305 // individual initialization for testing of each method
306 // overload this one for individual initialisation of the testing,
307 // it is then called automatically within the global "TestInit"
308
309 // variables (and private member functions) for the Evaluation:
310 // get the efficiency. It fills a histogram for efficiency/vs/bkg
311 // and returns the one value fo the efficiency demanded for
312 // in the TString argument. (Watch the string format)
313 virtual Double_t GetEfficiency( const TString&, Types::ETreeType, Double_t& err );
314 virtual Double_t GetTrainingEfficiency(const TString& );
315 virtual std::vector<Float_t> GetMulticlassEfficiency( std::vector<std::vector<Float_t> >& purity );
316 virtual std::vector<Float_t> GetMulticlassTrainingEfficiency(std::vector<std::vector<Float_t> >& purity );
318 virtual Double_t GetSignificance() const;
319 virtual Double_t GetROCIntegral(TH1D *histS, TH1D *histB) const;
320 virtual Double_t GetROCIntegral(PDF *pdfS=0, PDF *pdfB=0) const;
321 virtual Double_t GetMaximumSignificance( Double_t SignalEvents, Double_t BackgroundEvents,
322 Double_t& optimal_significance_value ) const;
323 virtual Double_t GetSeparation( TH1*, TH1* ) const;
324 virtual Double_t GetSeparation( PDF* pdfS = 0, PDF* pdfB = 0 ) const;
325
326 virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType type, Double_t& stddev,Double_t& stddev90Percent ) const;
327 // ---------- public accessors -----------------------------------------------
328
329 // classifier naming (a lot of names ... aren't they ;-)
330 const TString& GetJobName () const { return fJobName; }
331 const TString& GetMethodName () const { return fMethodName; }
334 const char* GetName () const { return fMethodName.Data(); }
335 const TString& GetTestvarName () const { return fTestvar; }
336 const TString GetProbaName () const { return fTestvar + "_Proba"; }
338
339 // build classifier name in Test tree
340 // MVA prefix (e.g., "TMVA_")
341 void SetTestvarName ( const TString & v="" ) { fTestvar = (v=="") ? ("MVA_" + GetMethodName()) : v; }
342
343 // number of input variable used by classifier
344 UInt_t GetNvar() const { return DataInfo().GetNVariables(); }
346 UInt_t GetNTargets() const { return DataInfo().GetNTargets(); };
347
348 // internal names and expressions of input variables
349 const TString& GetInputVar ( Int_t i ) const { return DataInfo().GetVariableInfo(i).GetInternalName(); }
350 const TString& GetInputLabel( Int_t i ) const { return DataInfo().GetVariableInfo(i).GetLabel(); }
351 const char * GetInputTitle( Int_t i ) const { return DataInfo().GetVariableInfo(i).GetTitle(); }
352
353 // normalisation and limit accessors
354 Double_t GetMean( Int_t ivar ) const { return GetTransformationHandler().GetMean(ivar); }
355 Double_t GetRMS ( Int_t ivar ) const { return GetTransformationHandler().GetRMS(ivar); }
356 Double_t GetXmin( Int_t ivar ) const { return GetTransformationHandler().GetMin(ivar); }
357 Double_t GetXmax( Int_t ivar ) const { return GetTransformationHandler().GetMax(ivar); }
358
359 // sets the minimum requirement on the MVA output to declare an event signal-like
362
363 // sets the minimum requirement on the MVA output to declare an event signal-like
366
367 // pointers to ROOT directories
368 TDirectory* BaseDir() const;
369 TDirectory* MethodBaseDir() const;
370 TFile* GetFile() const {return fFile;}
371
372 void SetMethodDir ( TDirectory* methodDir ) { fBaseDir = fMethodBaseDir = methodDir; }
373 void SetBaseDir( TDirectory* methodDir ){ fBaseDir = methodDir; }
374 void SetMethodBaseDir( TDirectory* methodDir ){ fMethodBaseDir = methodDir; }
376
377 //Silent file
378 void SetSilentFile(Bool_t status) {fSilentFile=status;}
380
381 //Model Persistence
382 void SetModelPersistence(Bool_t status){fModelPersistence=status;}//added support to create/remove dir here if exits or not
384
385 // the TMVA version can be obtained and checked using
386 // if (GetTrainingTMVAVersionCode()>TMVA_VERSION(3,7,2)) {...}
387 // or
388 // if (GetTrainingROOTVersionCode()>ROOT_VERSION(5,15,5)) {...}
393
395 {
396 if(fTransformationPointer && takeReroutedIfAvailable) return *fTransformationPointer; else return fTransformation;
397 }
398 const TransformationHandler& GetTransformationHandler(Bool_t takeReroutedIfAvailable=true) const
399 {
400 if(fTransformationPointer && takeReroutedIfAvailable) return *fTransformationPointer; else return fTransformation;
401 }
402
403 void RerouteTransformationHandler (TransformationHandler* fTargetTransformation) { fTransformationPointer=fTargetTransformation; }
404
405 // ---------- event accessors ------------------------------------------------
406
407 // returns reference to data set
408 // NOTE: this DataSet is the "original" dataset, i.e. the one seen by ALL Classifiers WITHOUT transformation
409 DataSet* Data() const { return (fTmpData) ? fTmpData : DataInfo().GetDataSet(); }
410 DataSetInfo& DataInfo() const { return fDataSetInfo; }
411
412
413 // event reference and update
414 // NOTE: these Event accessors make sure that you get the events transformed according to the
415 // particular classifiers transformation chosen
416 UInt_t GetNEvents () const { return Data()->GetNEvents(); }
417 const Event* GetEvent () const;
418 const Event* GetEvent ( const TMVA::Event* ev ) const;
419 const Event* GetEvent ( Long64_t ievt ) const;
420 const Event* GetEvent ( Long64_t ievt , Types::ETreeType type ) const;
421 const Event* GetTrainingEvent( Long64_t ievt ) const;
422 const Event* GetTestingEvent ( Long64_t ievt ) const;
423 const std::vector<TMVA::Event*>& GetEventCollection( Types::ETreeType type );
424
426 // ---------- public auxiliary methods ---------------------------------------
427
428 // this method is used to decide whether an event is signal- or background-like
429 // the reference cut "xC" is taken to be where
430 // Int_[-oo,xC] { PDF_S(x) dx } = Int_[xC,+oo] { PDF_B(x) dx }
431 virtual Bool_t IsSignalLike();
432 virtual Bool_t IsSignalLike(Double_t mvaVal);
433
434
435 Bool_t HasMVAPdfs() const { return fHasMVAPdfs; }
440
441 // setter method for suppressing writing to XML and writing of standalone classes
442 void DisableWriting(Bool_t setter){ fModelPersistence = setter?kFALSE:kTRUE; }//DEPRECATED
443
444 protected:
445 mutable const Event *fTmpEvent; //! temporary event when testing on a different DataSet than the own one
446 DataSet *fTmpData = nullptr; //! temporary dataset used when evaluating on a different data (used by MethodCategory::GetMvaValues)
447 // helper variables for JsMVA
449 bool fExitFromTraining = false;
451
452 public:
453
454 // initializing IPythonInteractive class (for JsMVA only)
456 if (fInteractive) delete fInteractive;
458 }
459
460 // get training errors (for JsMVA only)
462
463 // stop's the training process (for JsMVA only)
464 inline void ExitFromTraining(){
465 fExitFromTraining = true;
466 }
467
468 // check's if the training ended (for JsMVA only)
469 inline bool TrainingEnded(){
471 delete fInteractive;
472 fInteractive = nullptr;
473 }
474 return fExitFromTraining;
475 }
476
477 // get fIPyMaxIter
478 inline UInt_t GetMaxIter(){ return fIPyMaxIter; }
479
480 // get fIPyCurrentIter
482
483 protected:
484
485 // ---------- protected accessors -------------------------------------------
486
487 //TDirectory* LocalTDir() const { return Data().LocalRootDir(); }
488
489 // weight file name and directory (given by global config variable)
491
492 const TString& GetWeightFileDir() const { return fFileDir; }
493 void SetWeightFileDir( TString fileDir );
494
495 // are input variables normalised ?
496 Bool_t IsNormalised() const { return fNormalise; }
497 void SetNormalised( Bool_t norm ) { fNormalise = norm; }
498
499 // set number of input variables (only used by MethodCuts, could perhaps be removed)
500 // void SetNvar( Int_t n ) { fNvar = n; }
501
502 // verbose and help flags
503 Bool_t Verbose() const { return fVerbose; }
504 Bool_t Help () const { return fHelp; }
505
506 // ---------- protected event and tree accessors -----------------------------
507
508 // names of input variables (if the original names are expressions, they are
509 // transformed into regexps)
510 const TString& GetInternalVarName( Int_t ivar ) const { return (*fInputVars)[ivar]; }
511 const TString& GetOriginalVarName( Int_t ivar ) const { return DataInfo().GetVariableInfo(ivar).GetExpression(); }
512
513 Bool_t HasTrainingTree() const { return Data()->GetNTrainingEvents() != 0; }
514
515 // ---------- protected auxiliary methods ------------------------------------
516
517 protected:
518
519 // make ROOT-independent C++ class for classifier response (classifier-specific implementation)
520 virtual void MakeClassSpecific( std::ostream&, const TString& = "" ) const {}
521
522 // header and auxiliary classes
523 virtual void MakeClassSpecificHeader( std::ostream&, const TString& = "" ) const {}
524
525 // static pointer to this object - required for ROOT finder (to be solved differently)(solved by Omar)
526 //static MethodBase* GetThisBase();
527
528 // some basic statistical analysis
529 void Statistics( Types::ETreeType treeType, const TString& theVarName,
532
533 // if TRUE, write weights only to text files
534 Bool_t TxtWeightsOnly() const { return kTRUE; }
535
536 protected:
537
538 // access to event information that needs method-specific information
539
541
542 private:
543
544 // ---------- private definitions --------------------------------------------
545 // Initialisation
546 void InitBase();
547 void DeclareBaseOptions();
548 void ProcessBaseOptions();
549
550 // used in efficiency computation
553
554 // ---------- private accessors ---------------------------------------------
555
556 // reset required for RootFinder
558
559 // ---------- private auxiliary methods --------------------------------------
560
561 // PDFs for classifier response (required to compute signal probability and Rarity)
562 void CreateMVAPdfs();
563
564 // for root finder
565 //virtual method to find ROOT
566 virtual Double_t GetValueForRoot ( Double_t ); // implementation
567
568 // used for file parsing
569 Bool_t GetLine( std::istream& fin, char * buf );
570
571 // fill test tree with classification or regression results
576
577 private:
578
579 void AddInfoItem( void* gi, const TString& name,
580 const TString& value) const;
581
582 // ========== class members ==================================================
583
584 protected:
585
586 // direct accessors
587 Ranking* fRanking; // pointer to ranking object (created by derived classifiers)
588 std::vector<TString>* fInputVars; // vector of input variables used in MVA
589
590 // histogram binning
591 Int_t fNbins; // number of bins in input variable histograms
592 Int_t fNbinsMVAoutput; // number of bins in MVA output histograms
593 Int_t fNbinsH; // number of bins in evaluation histograms
594
595 Types::EAnalysisType fAnalysisType; // method-mode : true --> regression, false --> classification
596
597 std::vector<Float_t>* fRegressionReturnVal; // holds the return-values for the regression
598 std::vector<Float_t>* fMulticlassReturnVal; // holds the return-values for the multiclass classification
599
600 private:
601
602 // MethodCuts redefines some of the evaluation variables and histograms -> must access private members
603 friend class MethodCuts;
604
605
606 // data sets
607 DataSetInfo& fDataSetInfo; //! the data set information (sometimes needed)
608
609 Double_t fSignalReferenceCut; // minimum requirement on the MVA output to declare an event signal-like
610 Double_t fSignalReferenceCutOrientation; // minimum requirement on the MVA output to declare an event signal-like
611 Types::ESBType fVariableTransformType; // this is the event type (sig or bgd) assumed for variable transform
612
613 // naming and versioning
614 TString fJobName; // name of job -> user defined, appears in weight files
615 TString fMethodName; // name of the method (set in derived class)
616 Types::EMVA fMethodType; // type of method (set in derived class)
617 TString fTestvar; // variable used in evaluation, etc (mostly the MVA)
618 UInt_t fTMVATrainingVersion; // TMVA version used for training
619 UInt_t fROOTTrainingVersion; // ROOT version used for training
620 Bool_t fConstructedFromWeightFile; // is it obtained from weight file?
621
622 // Directory structure: dataloader/fMethodBaseDir/fBaseDir
623 // where the first directory name is defined by the method type
624 // and the second is user supplied (the title given in Factory::BookMethod())
625 TDirectory* fBaseDir; // base directory for the instance, needed to know where to jump back from localDir
626 mutable TDirectory* fMethodBaseDir; // base directory for the method
627 //this will be the next way to save results
629
630 //SilentFile
632 //Model Persistence
634
635 TString fParentDir; // method parent name, like booster name
636
637 TString fFileDir; // unix sub-directory for weight files (default: DataLoader's Name + "weights")
638 TString fWeightFile; // weight file name
639
640 private:
641
642 TH1* fEffS; // efficiency histogram for rootfinder
643
644 PDF* fDefaultPDF; // default PDF definitions
645 PDF* fMVAPdfS; // signal MVA PDF
646 PDF* fMVAPdfB; // background MVA PDF
647
648 // TH1D* fmvaS; // PDFs of MVA distribution (signal)
649 // TH1D* fmvaB; // PDFs of MVA distribution (background)
650 PDF* fSplS; // PDFs of MVA distribution (signal)
651 PDF* fSplB; // PDFs of MVA distribution (background)
652 TSpline* fSpleffBvsS; // splines for signal eff. versus background eff.
653
654 PDF* fSplTrainS; // PDFs of training MVA distribution (signal)
655 PDF* fSplTrainB; // PDFs of training MVA distribution (background)
656 TSpline* fSplTrainEffBvsS; // splines for training signal eff. versus background eff.
657
658 private:
659
660 // basic statistics quantities of MVA
661 Double_t fMeanS; // mean (signal)
662 Double_t fMeanB; // mean (background)
663 Double_t fRmsS; // RMS (signal)
664 Double_t fRmsB; // RMS (background)
665 Double_t fXmin; // minimum (signal and background)
666 Double_t fXmax; // maximum (signal and background)
667
668 // variable preprocessing
669 TString fVarTransformString; // labels variable transform method
670
671 TransformationHandler* fTransformationPointer; // pointer to the rest of transformations
672 TransformationHandler fTransformation; // the list of transformations
673
674
675 // help and verbosity
676 Bool_t fVerbose; // verbose flag
677 TString fVerbosityLevelString; // verbosity level (user input string)
678 EMsgType fVerbosityLevel; // verbosity level
679 Bool_t fHelp; // help flag
680 Bool_t fHasMVAPdfs; // MVA Pdfs are created for this classifier
681
682 Bool_t fIgnoreNegWeightsInTraining;// If true, events with negative weights are not used in training
683
684 protected:
685
687
688 // for signal/background
689 UInt_t fSignalClass; // index of the Signal-class
690 UInt_t fBackgroundClass; // index of the Background-class
691
692 private:
693
694 // timing variables
695 Double_t fTrainTime; // for timing measurements
696 Double_t fTestTime; // for timing measurements
697
698 // orientation of cut: depends on signal and background mean values
699 ECutOrientation fCutOrientation; // +1 if Sig>Bkg, -1 otherwise
700
701 // for root finder
702 TSpline1* fSplRefS; // helper splines for RootFinder (signal)
703 TSpline1* fSplRefB; // helper splines for RootFinder (background)
704
705 TSpline1* fSplTrainRefS; // helper splines for RootFinder (signal)
706 TSpline1* fSplTrainRefB; // helper splines for RootFinder (background)
707
708 mutable std::vector<const std::vector<TMVA::Event*>*> fEventCollections; // if the method needs the complete event-collection, the transformed event coll. ist stored here.
709
710 public:
711 Bool_t fSetupCompleted; // is method setup
712
713 private:
714
715 // This is a workaround for OSx where static thread_local data members are
716 // not supported. The C++ solution would indeed be the following:
717// static MethodBase*& GetThisBaseThreadLocal() {TTHREAD_TLS(MethodBase*) fgThisBase(nullptr); return fgThisBase; };
718
719 // ===== depreciated options, kept for backward compatibility =====
720 private:
721
722 Bool_t fNormalise; // normalise input variables
723 Bool_t fUseDecorr; // synonymous for decorrelation
724 TString fVariableTransformTypeString; // labels variable transform type
725 Bool_t fTxtWeightsOnly; // if TRUE, write weights only to text files
726 Int_t fNbinsMVAPdf; // number of bins used in histogram that creates PDF
727 Int_t fNsmoothMVAPdf; // number of times a histogram is smoothed before creating the PDF
728
729 protected:
731 ClassDef(MethodBase,0); // Virtual base class for all TMVA method
732
733 };
734} // namespace TMVA
735
736
737
738
739
740
741
742// ========== INLINE FUNCTIONS =========================================================
743
744
745//_______________________________________________________________________
746inline const TMVA::Event* TMVA::MethodBase::GetEvent( const TMVA::Event* ev ) const
747{
749}
750
752{
753 if(fTmpEvent)
754 return GetTransformationHandler().Transform(fTmpEvent);
755 else
756 return GetTransformationHandler().Transform(Data()->GetEvent());
757}
758
760{
761 assert(fTmpEvent==0);
762 return GetTransformationHandler().Transform(Data()->GetEvent(ievt));
763}
764
766{
767 assert(fTmpEvent==0);
768 return GetTransformationHandler().Transform(Data()->GetEvent(ievt, type));
769}
770
772{
773 assert(fTmpEvent==0);
774 return GetEvent(ievt, Types::kTraining);
775}
776
778{
779 assert(fTmpEvent==0);
780 return GetEvent(ievt, Types::kTesting);
781}
782
783#endif
int Int_t
Definition: RtypesCore.h:45
char Char_t
Definition: RtypesCore.h:33
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
long long Long64_t
Definition: RtypesCore.h:80
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDef(name, id)
Definition: Rtypes.h:325
char name[80]
Definition: TGX11.cxx:110
int type
Definition: TGX11.cxx:121
Describe directory structure in memory.
Definition: TDirectory.h:45
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
A TGraph is an object made of two arrays X and Y with npoints each.
Definition: TGraph.h:41
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:618
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:575
TH1 is the base class of all histogram classes in ROOT.
Definition: TH1.h:58
Class to perform two class classification.
Class to perform cross validation, splitting the dataloader into folds.
Class that contains all the data information.
Definition: DataSetInfo.h:62
UInt_t GetNVariables() const
Definition: DataSetInfo.h:127
UInt_t GetNTargets() const
Definition: DataSetInfo.h:128
DataSet * GetDataSet() const
returns data set
VariableInfo & GetVariableInfo(Int_t i)
Definition: DataSetInfo.h:105
Class that contains all the data information.
Definition: DataSet.h:58
Long64_t GetNEvents(Types::ETreeType type=Types::kMaxTreeType) const
Definition: DataSet.h:206
Long64_t GetNTrainingEvents() const
Definition: DataSet.h:68
This is the main MVA steering class.
Definition: Factory.h:80
Interface for all concrete MVA method implementations.
Definition: IMethod.h:53
This class is needed by JsMVA, and it's a helper class for tracking errors during the training in Jup...
Definition: MethodBase.h:94
void Init(std::vector< TString > &graphTitles)
This function gets some title and it creates a TGraph for every title.
Definition: MethodBase.cxx:169
IPythonInteractive()
standard constructor
Definition: MethodBase.cxx:146
TMultiGraph * fMultiGraph
Definition: MethodBase.h:103
std::vector< TGraph * > fGraphs
Definition: MethodBase.h:106
~IPythonInteractive()
standard destructor
Definition: MethodBase.cxx:154
TMultiGraph * Get()
Definition: MethodBase.h:102
void ClearGraphs()
This function sets the point number to 0 for all graphs.
Definition: MethodBase.cxx:193
void AddPoint(Double_t x, Double_t y1, Double_t y2)
This function is used only in 2 TGraph case, and it will add new data points to graphs.
Definition: MethodBase.cxx:207
Virtual base Class for all MVA method.
Definition: MethodBase.h:111
TransformationHandler * fTransformationPointer
Definition: MethodBase.h:671
virtual void MakeClassSpecificHeader(std::ostream &, const TString &="") const
Definition: MethodBase.h:523
TString fVerbosityLevelString
Definition: MethodBase.h:677
TDirectory * MethodBaseDir() const
returns the ROOT directory where all instances of the corresponding MVA method are stored
virtual const std::vector< Float_t > & GetRegressionValues()
Definition: MethodBase.h:221
const std::vector< Float_t > & GetRegressionValues(const TMVA::Event *const ev)
Definition: MethodBase.h:214
virtual void Train()=0
virtual Double_t GetKSTrainingVsTest(Char_t SorB, TString opt="X")
MethodBase(const TString &jobName, Types::EMVA methodType, const TString &methodTitle, DataSetInfo &dsi, const TString &theOption="")
standard constructor
Definition: MethodBase.cxx:237
TString fMethodName
Definition: MethodBase.h:615
TFile * GetFile() const
Definition: MethodBase.h:370
virtual Double_t GetSeparation(TH1 *, TH1 *) const
compute "separation" defined as
TString fFileDir
Definition: MethodBase.h:637
DataSet * fTmpData
temporary event when testing on a different DataSet than the own one
Definition: MethodBase.h:446
Bool_t HasTrainingTree() const
Definition: MethodBase.h:513
virtual void DeclareOptions()=0
void SetSilentFile(Bool_t status)
Definition: MethodBase.h:378
void ReadClassesFromXML(void *clsnode)
read number of classes from XML
TMultiGraph * GetInteractiveTrainingError()
Definition: MethodBase.h:461
void SetWeightFileDir(TString fileDir)
set directory of weight file
void WriteStateToXML(void *parent) const
general method used in writing the header of the weight files where the used variables,...
Bool_t fSilentFile
Definition: MethodBase.h:631
void DeclareBaseOptions()
define the options (their key words) that can be set in the option string here the options valid for ...
Definition: MethodBase.cxx:509
UInt_t GetMaxIter()
Definition: MethodBase.h:478
Double_t fRmsB
Definition: MethodBase.h:664
Double_t GetXmin(Int_t ivar) const
Definition: MethodBase.h:356
Bool_t Verbose() const
Definition: MethodBase.h:503
virtual void TestRegression(Double_t &bias, Double_t &biasT, Double_t &dev, Double_t &devT, Double_t &rms, Double_t &rmsT, Double_t &mInf, Double_t &mInfT, Double_t &corr, Types::ETreeType type)
calculate <sum-of-deviation-squared> of regression output versus "true" value from test sample
Definition: MethodBase.cxx:991
Double_t GetMean(Int_t ivar) const
Definition: MethodBase.h:354
virtual void DeclareCompatibilityOptions()
options that are used ONLY for the READER to ensure backward compatibility they are hence without any...
Definition: MethodBase.cxx:596
TString GetMethodTypeName() const
Definition: MethodBase.h:332
Bool_t DoMulticlass() const
Definition: MethodBase.h:439
virtual Double_t GetSignificance() const
compute significance of mean difference
void DisableWriting(Bool_t setter)
Definition: MethodBase.h:442
Bool_t fTxtWeightsOnly
Definition: MethodBase.h:725
virtual void ReadWeightsFromXML(void *wghtnode)=0
virtual Double_t GetProba(const Event *ev)
const char * GetName() const
Definition: MethodBase.h:334
TString fParentDir
Definition: MethodBase.h:635
virtual const std::vector< Float_t > & GetMulticlassValues()
Definition: MethodBase.h:227
TSpline * fSplTrainEffBvsS
Definition: MethodBase.h:656
Types::EAnalysisType GetAnalysisType() const
Definition: MethodBase.h:437
virtual TMatrixD GetMulticlassConfusionMatrix(Double_t effB, Types::ETreeType type)
Construct a confusion matrix for a multiclass classifier.
UInt_t GetTrainingTMVAVersionCode() const
Definition: MethodBase.h:389
UInt_t fTMVATrainingVersion
Definition: MethodBase.h:618
Bool_t IsModelPersistence() const
Definition: MethodBase.h:383
Double_t fXmax
Definition: MethodBase.h:666
Double_t fMeanS
Definition: MethodBase.h:661
Types::ESBType fVariableTransformType
Definition: MethodBase.h:611
const TString & GetInputVar(Int_t i) const
Definition: MethodBase.h:349
void PrintHelpMessage() const
prints out method-specific help method
void SetMethodDir(TDirectory *methodDir)
Definition: MethodBase.h:372
const TString & GetJobName() const
Definition: MethodBase.h:330
Bool_t IgnoreEventsWithNegWeightsInTraining() const
Definition: MethodBase.h:686
Double_t fTrainTime
Definition: MethodBase.h:695
virtual void WriteEvaluationHistosToFile(Types::ETreeType treetype)
writes all MVA evaluation histograms to file
virtual void TestMulticlass()
test multiclass classification
Bool_t fModelPersistence
Definition: MethodBase.h:633
const TString & GetTestvarName() const
Definition: MethodBase.h:335
const std::vector< TMVA::Event * > & GetEventCollection(Types::ETreeType type)
returns the event collection (i.e.
virtual std::vector< Double_t > GetDataMvaValues(DataSet *data=nullptr, Long64_t firstEvt=0, Long64_t lastEvt=-1, Bool_t logProgress=false)
get all the MVA values for the events of the given Data type
Definition: MethodBase.cxx:939
void SetupMethod()
setup of methods
Definition: MethodBase.cxx:406
TDirectory * BaseDir() const
returns the ROOT directory where info/histograms etc of the corresponding MVA method instance are sto...
const Event * GetTestingEvent(Long64_t ievt) const
Definition: MethodBase.h:777
virtual std::vector< Float_t > GetMulticlassEfficiency(std::vector< std::vector< Float_t > > &purity)
UInt_t GetNTargets() const
Definition: MethodBase.h:346
EMsgType fVerbosityLevel
Definition: MethodBase.h:678
const TString GetProbaName() const
Definition: MethodBase.h:336
UInt_t fIPyMaxIter
Definition: MethodBase.h:450
TransformationHandler fTransformation
Definition: MethodBase.h:672
virtual void ReadWeightsFromStream(std::istream &)=0
void AddInfoItem(void *gi, const TString &name, const TString &value) const
xml writing
TDirectory * fMethodBaseDir
Definition: MethodBase.h:626
virtual void AddClassifierOutputProb(Types::ETreeType type)
prepare tree branch with the method's discriminating variable
Definition: MethodBase.cxx:950
virtual void MakeClassSpecific(std::ostream &, const TString &="") const
Definition: MethodBase.h:520
Double_t fSignalReferenceCutOrientation
Definition: MethodBase.h:610
virtual Double_t GetEfficiency(const TString &, Types::ETreeType, Double_t &err)
fill background efficiency (resp.
Int_t fNbinsMVAoutput
Definition: MethodBase.h:592
TString GetTrainingTMVAVersionString() const
calculates the TMVA version string from the training version code on the fly
TSpline * fSpleffBvsS
Definition: MethodBase.h:652
TString fVariableTransformTypeString
Definition: MethodBase.h:724
TSpline1 * fSplTrainRefB
Definition: MethodBase.h:706
const TString & GetWeightFileDir() const
Definition: MethodBase.h:492
virtual void SetAnalysisType(Types::EAnalysisType type)
Definition: MethodBase.h:436
UInt_t GetCurrentIter()
Definition: MethodBase.h:481
TString fTestvar
Definition: MethodBase.h:617
const TString & GetMethodName() const
Definition: MethodBase.h:331
Bool_t TxtWeightsOnly() const
Definition: MethodBase.h:534
void Statistics(Types::ETreeType treeType, const TString &theVarName, Double_t &, Double_t &, Double_t &, Double_t &, Double_t &, Double_t &)
calculates rms,mean, xmin, xmax of the event variable this can be either done for the variables as th...
virtual void ReadWeightsFromStream(TFile &)
Definition: MethodBase.h:266
void ExitFromTraining()
Definition: MethodBase.h:464
UInt_t GetNEvents() const
Definition: MethodBase.h:416
Bool_t DoRegression() const
Definition: MethodBase.h:438
std::vector< Float_t > * fRegressionReturnVal
Definition: MethodBase.h:597
std::vector< Float_t > * fMulticlassReturnVal
Definition: MethodBase.h:598
Double_t fRmsS
Definition: MethodBase.h:663
Bool_t GetLine(std::istream &fin, char *buf)
reads one line from the input stream checks for certain keywords and interprets the line if keywords ...
const Event * GetEvent() const
Definition: MethodBase.h:751
TString fVarTransformString
Definition: MethodBase.h:669
void ProcessSetup()
process all options the "CheckForUnusedOptions" is done in an independent call, since it may be overr...
Definition: MethodBase.cxx:423
virtual void ProcessOptions()=0
virtual std::vector< Double_t > GetMvaValues(Long64_t firstEvt=0, Long64_t lastEvt=-1, Bool_t logProgress=false)
get all the MVA values for the events of the current Data type
Definition: MethodBase.cxx:897
virtual Bool_t IsSignalLike()
uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation) for...
Definition: MethodBase.cxx:854
void RerouteTransformationHandler(TransformationHandler *fTargetTransformation)
Definition: MethodBase.h:403
virtual ~MethodBase()
destructor
Definition: MethodBase.cxx:364
Bool_t HasMVAPdfs() const
Definition: MethodBase.h:435
UInt_t fBackgroundClass
Definition: MethodBase.h:690
Double_t fTestTime
Definition: MethodBase.h:696
virtual Double_t GetMaximumSignificance(Double_t SignalEvents, Double_t BackgroundEvents, Double_t &optimal_significance_value) const
plot significance, , curve for given number of signal and background events; returns cut for maximum ...
virtual Double_t GetTrainingEfficiency(const TString &)
void SetWeightFileName(TString)
set the weight file name (depreciated)
DataSetInfo & DataInfo() const
Definition: MethodBase.h:410
virtual void MakeClass(const TString &classFileName=TString("")) const
create reader class for method (classification only at present)
TString GetWeightFileName() const
retrieve weight file name
void SetTestTime(Double_t testTime)
Definition: MethodBase.h:165
Types::EMVA fMethodType
Definition: MethodBase.h:616
virtual void TestClassification()
initialization
void AddOutput(Types::ETreeType type, Types::EAnalysisType analysisType)
virtual void WriteMonitoringHistosToFile() const
write special monitoring histograms to file dummy implementation here --------------—
UInt_t GetNVariables() const
Definition: MethodBase.h:345
Types::EAnalysisType fAnalysisType
Definition: MethodBase.h:595
virtual void AddRegressionOutput(Types::ETreeType type)
prepare tree branch with the method's discriminating variable
Definition: MethodBase.cxx:744
void InitBase()
default initialization called by all constructors
Definition: MethodBase.cxx:441
std::vector< const std::vector< TMVA::Event * > * > fEventCollections
Definition: MethodBase.h:708
bool TrainingEnded()
Definition: MethodBase.h:469
virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType type, Double_t &stddev, Double_t &stddev90Percent) const
Definition: MethodBase.cxx:724
void InitIPythonInteractive()
Definition: MethodBase.h:455
void ReadStateFromXMLString(const char *xmlstr)
for reading from memory
Bool_t fSetupCompleted
Definition: MethodBase.h:711
void CreateMVAPdfs()
Create PDFs of the MVA output variables.
TString GetTrainingROOTVersionString() const
calculates the ROOT version string from the training version code on the fly
virtual Double_t GetValueForRoot(Double_t)
returns efficiency as function of cut
UInt_t GetTrainingROOTVersionCode() const
Definition: MethodBase.h:390
void ReadStateFromFile()
Function to write options and weights to file.
void WriteVarsToStream(std::ostream &tf, const TString &prefix="") const
write the list of variables (name, min, max) for a given data transformation method to the stream
void ReadVarsFromStream(std::istream &istr)
Read the variables (name, min, max) for a given data transformation method from the stream.
virtual void AddWeightsXMLTo(void *parent) const =0
virtual void Init()=0
void ReadSpectatorsFromXML(void *specnode)
read spectator info from XML
virtual const std::vector< Float_t > & GetTrainingHistory(const char *)
Definition: MethodBase.h:233
const Event * fTmpEvent
Definition: MethodBase.h:445
virtual Double_t GetMvaValue(Double_t *errLower=0, Double_t *errUpper=0)=0
bool fExitFromTraining
Definition: MethodBase.h:449
void SetNormalised(Bool_t norm)
Definition: MethodBase.h:497
void SetTestvarName(const TString &v="")
Definition: MethodBase.h:341
void ReadVariablesFromXML(void *varnode)
read variable info from XML
Bool_t fConstructedFromWeightFile
Definition: MethodBase.h:620
UInt_t GetNvar() const
Definition: MethodBase.h:344
virtual std::map< TString, Double_t > OptimizeTuningParameters(TString fomType="ROCIntegral", TString fitType="FitGA")
call the Optimizer with the set of parameters and ranges that are meant to be tuned.
Definition: MethodBase.cxx:623
void SetTrainTime(Double_t trainTime)
Definition: MethodBase.h:161
Double_t GetXmax(Int_t ivar) const
Definition: MethodBase.h:357
virtual std::vector< Float_t > GetMulticlassTrainingEfficiency(std::vector< std::vector< Float_t > > &purity)
DataSetInfo & fDataSetInfo
Definition: MethodBase.h:607
Bool_t fHasMVAPdfs
Definition: MethodBase.h:680
void WriteStateToStream(std::ostream &tf) const
general method used in writing the header of the weight files where the used variables,...
virtual Double_t GetRarity(Double_t mvaVal, Types::ESBType reftype=Types::kBackground) const
compute rarity:
virtual void SetTuneParameters(std::map< TString, Double_t > tuneParameters)
set the tuning parameters according to the argument This is just a dummy .
Definition: MethodBase.cxx:644
Double_t GetTrainTime() const
Definition: MethodBase.h:162
void SetBaseDir(TDirectory *methodDir)
Definition: MethodBase.h:373
void ReadStateFromStream(std::istream &tf)
read the header from the weight files of the different MVA methods
void AddVarsXMLTo(void *parent) const
write variable info to XML
Bool_t Help() const
Definition: MethodBase.h:504
TSpline1 * fSplRefB
Definition: MethodBase.h:703
TString fJobName
Definition: MethodBase.h:614
UInt_t fIPyCurrentIter
Definition: MethodBase.h:450
TransformationHandler & GetTransformationHandler(Bool_t takeReroutedIfAvailable=true)
Definition: MethodBase.h:394
Bool_t IsSilentFile() const
Definition: MethodBase.h:379
Types::EMVA GetMethodType() const
Definition: MethodBase.h:333
void AddTargetsXMLTo(void *parent) const
write target info to XML
Results * fResults
Definition: MethodBase.h:730
Double_t fXmin
Definition: MethodBase.h:665
void ReadTargetsFromXML(void *tarnode)
read target info from XML
void SetFile(TFile *file)
Definition: MethodBase.h:375
void ProcessBaseOptions()
the option string is decoded, for available options see "DeclareOptions"
Definition: MethodBase.cxx:540
virtual void Reset()
Definition: MethodBase.h:193
UInt_t fROOTTrainingVersion
Definition: MethodBase.h:619
void ReadStateFromXML(void *parent)
Double_t GetSignalReferenceCutOrientation() const
Definition: MethodBase.h:361
void SetSignalReferenceCut(Double_t cut)
Definition: MethodBase.h:364
std::vector< TString > * fInputVars
Definition: MethodBase.h:588
void NoErrorCalc(Double_t *const err, Double_t *const errUpper)
Definition: MethodBase.cxx:836
Double_t fSignalReferenceCut
the data set information (sometimes needed)
Definition: MethodBase.h:609
Double_t GetTestTime() const
Definition: MethodBase.h:166
UInt_t fSignalClass
Definition: MethodBase.h:689
Double_t fMeanB
Definition: MethodBase.h:662
const TransformationHandler & GetTransformationHandler(Bool_t takeReroutedIfAvailable=true) const
Definition: MethodBase.h:398
Int_t fNsmoothMVAPdf
Definition: MethodBase.h:727
void SetSignalReferenceCutOrientation(Double_t cutOrientation)
Definition: MethodBase.h:365
TDirectory * fBaseDir
Definition: MethodBase.h:625
Bool_t fIgnoreNegWeightsInTraining
Definition: MethodBase.h:682
void WriteStateToFile() const
write options and weights to file note that each one text file for the main configuration information...
void AddClassesXMLTo(void *parent) const
write class info to XML
const TString & GetInputLabel(Int_t i) const
Definition: MethodBase.h:350
ECutOrientation GetCutOrientation() const
Definition: MethodBase.h:552
Ranking * fRanking
Definition: MethodBase.h:587
TrainingHistory fTrainHistory
Definition: MethodBase.h:425
void SetMethodBaseDir(TDirectory *methodDir)
Definition: MethodBase.h:374
virtual void AddClassifierOutput(Types::ETreeType type)
prepare tree branch with the method's discriminating variable
Definition: MethodBase.cxx:868
DataSet * Data() const
Definition: MethodBase.h:409
void AddSpectatorsXMLTo(void *parent) const
write spectator info to XML
void SetModelPersistence(Bool_t status)
Definition: MethodBase.h:382
TString fWeightFile
Definition: MethodBase.h:638
Bool_t IsNormalised() const
Definition: MethodBase.h:496
const TString & GetInternalVarName(Int_t ivar) const
Definition: MethodBase.h:510
const Event * GetTrainingEvent(Long64_t ievt) const
Definition: MethodBase.h:771
Double_t GetSignalReferenceCut() const
Definition: MethodBase.h:360
TSpline1 * fSplTrainRefS
Definition: MethodBase.h:705
TSpline1 * fSplRefS
Definition: MethodBase.h:702
virtual Double_t GetROCIntegral(TH1D *histS, TH1D *histB) const
calculate the area (integral) under the ROC curve as a overall quality measure of the classification
ECutOrientation fCutOrientation
Definition: MethodBase.h:699
virtual const Ranking * CreateRanking()=0
Double_t GetRMS(Int_t ivar) const
Definition: MethodBase.h:355
IPythonInteractive * fInteractive
temporary dataset used when evaluating on a different data (used by MethodCategory::GetMvaValues)
Definition: MethodBase.h:448
const char * GetInputTitle(Int_t i) const
Definition: MethodBase.h:351
const TString & GetOriginalVarName(Int_t ivar) const
Definition: MethodBase.h:511
virtual void AddMulticlassOutput(Types::ETreeType type)
prepare tree branch with the method's discriminating variable
Definition: MethodBase.cxx:794
Bool_t IsConstructedFromWeightFile() const
Definition: MethodBase.h:540
virtual void CheckSetup()
check may be overridden by derived class (sometimes, eg, fitters are used which can only be implement...
Definition: MethodBase.cxx:433
Class for boosting a TMVA method.
Definition: MethodBoost.h:58
Class for categorizing the phase space.
Virtual base class for combining several TMVA method.
Multivariate optimisation of signal efficiency for given background efficiency, applying rectangular ...
Definition: MethodCuts.h:61
PDF wrapper for histograms; uses user-defined spline interpolation.
Definition: PDF.h:63
Ranking for variables in method (implementation)
Definition: Ranking.h:48
Class that is the base-class for a vector of result.
Definition: Results.h:57
Root finding using Brents algorithm (translated from CERNLIB function RZERO)
Definition: RootFinder.h:48
Linear interpolation of TGraph.
Definition: TSpline1.h:43
Tracking data from training.
Class that contains all the data information.
const Event * Transform(const Event *) const
the transformation
Double_t GetRMS(Int_t ivar, Int_t cls=-1) const
Double_t GetMean(Int_t ivar, Int_t cls=-1) const
Double_t GetMin(Int_t ivar, Int_t cls=-1) const
Double_t GetMax(Int_t ivar, Int_t cls=-1) const
TString GetMethodName(Types::EMVA method) const
Definition: Types.cxx:136
static Types & Instance()
the the single instance of "Types" if existing already, or create it (Singleton)
Definition: Types.cxx:70
@ kBackground
Definition: Types.h:136
EAnalysisType
Definition: Types.h:126
@ kMulticlass
Definition: Types.h:129
@ kRegression
Definition: Types.h:128
@ kTraining
Definition: Types.h:143
@ kTesting
Definition: Types.h:144
const TString & GetLabel() const
Definition: VariableInfo.h:59
const TString & GetExpression() const
Definition: VariableInfo.h:57
const TString & GetInternalName() const
Definition: VariableInfo.h:58
EMsgType
Definition: Types.h:55
A TMultiGraph is a collection of TGraph (or derived) objects.
Definition: TMultiGraph.h:36
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
Base class for spline implementation containing the Draw/Paint methods.
Definition: TSpline.h:31
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
A TTree represents a columnar dataset.
Definition: TTree.h:79
Double_t x[n]
Definition: legend1.C:17
create variable transformations
Definition: file.py:1