Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 * *
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 * (see tmva/doc/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();
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 = nullptr, Double_t* errUpper = nullptr) = 0;
199
200 // signal/background classification response
201 Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = nullptr, Double_t* errUpper = nullptr );
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 = nullptr;
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=nullptr, PDF *pdfB=nullptr) 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 = nullptr, PDF* pdfB = nullptr ) 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; }
375 void SetFile(TFile* file){fFile=file;}
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==nullptr);
762 return GetTransformationHandler().Transform(Data()->GetEvent(ievt));
763}
764
766{
767 assert(fTmpEvent==nullptr);
768 return GetTransformationHandler().Transform(Data()->GetEvent(ievt, type));
769}
770
772{
773 assert(fTmpEvent==nullptr);
774 return GetEvent(ievt, Types::kTraining);
775}
776
778{
779 assert(fTmpEvent==nullptr);
780 return GetEvent(ievt, Types::kTesting);
781}
782
783#endif
char Char_t
Definition RtypesCore.h:37
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
long long Long64_t
Definition RtypesCore.h:80
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
#define ClassDef(name, id)
Definition Rtypes.h:337
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Option_t Option_t TPoint TPoint const char y1
char name[80]
Definition TGX11.cxx:110
Describe directory structure in memory.
Definition TDirectory.h:45
A ROOT file is composed of a header, followed by consecutive data records (TKey instances) with a wel...
Definition TFile.h:53
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:621
1-D histogram with a float per channel (see TH1 documentation)}
Definition TH1.h:578
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
UInt_t GetNTargets() const
DataSet * GetDataSet() const
returns data set
VariableInfo & GetVariableInfo(Int_t i)
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.
IPythonInteractive()
standard constructor
TMultiGraph * fMultiGraph
Definition MethodBase.h:105
std::vector< TGraph * > fGraphs
Definition MethodBase.h:106
~IPythonInteractive()
standard destructor
TMultiGraph * Get()
Definition MethodBase.h:102
void ClearGraphs()
This function sets the point number to 0 for all graphs.
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.
Virtual base Class for all MVA method.
Definition MethodBase.h:111
TransformationHandler * fTransformationPointer
pointer to the rest of transformations
Definition MethodBase.h:671
virtual void MakeClassSpecificHeader(std::ostream &, const TString &="") const
Definition MethodBase.h:523
TString fVerbosityLevelString
verbosity level (user input string)
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
PDF * fSplB
PDFs of MVA distribution (background)
Definition MethodBase.h:651
Bool_t fVerbose
verbose flag
Definition MethodBase.h:676
virtual Double_t GetKSTrainingVsTest(Char_t SorB, TString opt="X")
TString fMethodName
Definition MethodBase.h:615
virtual Double_t GetMvaValue(Double_t *errLower=nullptr, Double_t *errUpper=nullptr)=0
TFile * GetFile() const
Definition MethodBase.h:370
virtual Double_t GetSeparation(TH1 *, TH1 *) const
compute "separation" defined as
TString fFileDir
unix sub-directory for weight files (default: DataLoader's Name + "weights")
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,...
void DeclareBaseOptions()
define the options (their key words) that can be set in the option string here the options valid for ...
UInt_t GetMaxIter()
Definition MethodBase.h:478
Double_t fRmsB
RMS (background)
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
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...
PDF * fSplTrainB
PDFs of training MVA distribution (background)
Definition MethodBase.h:655
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)
TH1 * fEffS
efficiency histogram for rootfinder
Definition MethodBase.h:642
const char * GetName() const
Definition MethodBase.h:334
TString fParentDir
method parent name, like booster name
Definition MethodBase.h:635
virtual const std::vector< Float_t > & GetMulticlassValues()
Definition MethodBase.h:227
TSpline * fSplTrainEffBvsS
splines for training signal eff. versus background eff.
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
maximum (signal and background)
Definition MethodBase.h:666
Double_t fMeanS
mean (signal)
Definition MethodBase.h:661
Types::ESBType fVariableTransformType
Definition MethodBase.h:611
const TString & GetInputVar(Int_t i) const
Definition MethodBase.h:349
PDF * fSplTrainS
PDFs of training MVA distribution (signal)
Definition MethodBase.h:654
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
void SetupMethod()
setup of methods
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
verbosity level
Definition MethodBase.h:678
const TString GetProbaName() const
Definition MethodBase.h:336
TransformationHandler fTransformation
the list of transformations
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
PDF * fSplS
PDFs of MVA distribution (signal)
Definition MethodBase.h:650
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.
TString GetTrainingTMVAVersionString() const
calculates the TMVA version string from the training version code on the fly
TSpline * fSpleffBvsS
splines for signal eff. versus background eff.
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
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
RMS (signal)
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
labels variable transform method
Definition MethodBase.h:669
void ProcessSetup()
process all options the "CheckForUnusedOptions" is done in an independent call, since it may be overr...
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
virtual Bool_t IsSignalLike()
uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation) for...
void RerouteTransformationHandler(TransformationHandler *fTargetTransformation)
Definition MethodBase.h:403
virtual ~MethodBase()
destructor
Bool_t HasMVAPdfs() const
Definition MethodBase.h:435
PDF * fMVAPdfS
signal MVA PDF
Definition MethodBase.h:645
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
void InitBase()
default initialization called by all constructors
std::vector< const std::vector< TMVA::Event * > * > fEventCollections
Definition MethodBase.h:708
virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType type, Double_t &stddev, Double_t &stddev90Percent) const
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
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
Bool_t fHelp
help flag
Definition MethodBase.h:679
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.
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
MVA Pdfs are created for this classifier.
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 .
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
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
minimum (signal and background)
Definition MethodBase.h:665
PDF * fDefaultPDF
default PDF definitions
Definition MethodBase.h:644
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"
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)
Double_t fSignalReferenceCut
the data set information (sometimes needed)
Definition MethodBase.h:609
Double_t GetTestTime() const
Definition MethodBase.h:166
Double_t fMeanB
mean (background)
Definition MethodBase.h:662
const TransformationHandler & GetTransformationHandler(Bool_t takeReroutedIfAvailable=true) const
Definition MethodBase.h:398
void SetSignalReferenceCutOrientation(Double_t cutOrientation)
Definition MethodBase.h:365
TDirectory * fBaseDir
Definition MethodBase.h:625
Bool_t fIgnoreNegWeightsInTraining
If true, events with negative weights are not used in training.
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
PDF * fMVAPdfB
background MVA PDF
Definition MethodBase.h:646
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
weight file name
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
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...
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 single instance of "Types" if existing already, or create it (Singleton)
Definition Types.cxx:70
@ kBackground
Definition Types.h:136
@ kMulticlass
Definition Types.h:129
@ kRegression
Definition Types.h:128
@ kTraining
Definition Types.h:143
const TString & GetLabel() const
const TString & GetExpression() const
const TString & GetInternalName() const
A TMultiGraph is a collection of TGraph (or derived) objects.
Definition TMultiGraph.h:34
const char * GetTitle() const override
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:139
const char * Data() const
Definition TString.h:378
A TTree represents a columnar dataset.
Definition TTree.h:79
Double_t x[n]
Definition legend1.C:17
create variable transformations