Logo ROOT  
Reference Guide
Go to the documentation of this file.
1// @(#)root/tmva $Id$
2// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Jan Therhaag
5 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6 * Package: TMVA *
7 * Class : MethodBDT (Boosted Decision Trees) *
8 * Web : http://tmva.sourceforge.net *
9 * *
10 * Description: *
11 * Analysis of Boosted Decision Trees *
12 * *
13 * Authors (alphabetical): *
14 * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
15 * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany *
16 * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
17 * Doug Schouten <dschoute@sfu.ca> - Simon Fraser U., Canada *
18 * Jan Therhaag <jan.therhaag@cern.ch> - U. of Bonn, Germany *
19 * *
20 * Copyright (c) 2005-2011: *
21 * CERN, Switzerland *
22 * U. of Victoria, Canada *
23 * MPI-K Heidelberg, Germany *
24 * U. of Bonn, Germany *
25 * *
26 * Redistribution and use in source and binary forms, with or without *
27 * modification, are permitted according to the terms listed in LICENSE *
28 * (http://tmva.sourceforge.net/LICENSE) *
29 **********************************************************************************/
31#ifndef ROOT_TMVA_MethodBDT
32#define ROOT_TMVA_MethodBDT
35// //
36// MethodBDT //
37// //
38// Analysis of Boosted Decision Trees //
39// //
42#include <vector>
43#include <memory>
44#include "TH2.h"
45#include "TTree.h"
46#include "TMVA/MethodBase.h"
47#include "TMVA/DecisionTree.h"
48#include "TMVA/Event.h"
49#include "TMVA/LossFunction.h"
51// Multithreading only if the compilation flag is turned on
52#ifdef R__USE_IMT
54#include "TSystem.h"
57namespace TMVA {
59 class SeparationBase;
61 class MethodBDT : public MethodBase {
63 public:
65 // constructor for training and reading
66 MethodBDT( const TString& jobName,
67 const TString& methodTitle,
68 DataSetInfo& theData,
69 const TString& theOption = "");
71 // constructor for calculating BDT-MVA using previously generatad decision trees
72 MethodBDT( DataSetInfo& theData,
73 const TString& theWeightFile);
75 virtual ~MethodBDT( void );
77 virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets );
80 // write all Events from the Tree into a vector of Events, that are
81 // more easily manipulated
82 void InitEventSample();
84 // optimize tuning parameters
85 virtual std::map<TString,Double_t> OptimizeTuningParameters(TString fomType="ROCIntegral", TString fitType="FitGA");
86 virtual void SetTuneParameters(std::map<TString,Double_t> tuneParameters);
88 // training method
89 void Train( void );
91 // revoke training
92 void Reset( void );
96 // write weights to file
97 void AddWeightsXMLTo( void* parent ) const;
99 // read weights from file
100 void ReadWeightsFromStream( std::istream& istr );
101 void ReadWeightsFromXML(void* parent);
103 // write method specific histos to target file
104 void WriteMonitoringHistosToFile( void ) const;
106 // calculate the MVA value
107 Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0);
109 // get the actual forest size (might be less than fNTrees, the requested one, if boosting is stopped early
110 UInt_t GetNTrees() const {return fForest.size();}
111 private:
113 Double_t GetMvaValue( Double_t* err, Double_t* errUpper, UInt_t useNTrees );
114 Double_t PrivateGetMvaValue( const TMVA::Event *ev, Double_t* err=0, Double_t* errUpper=0, UInt_t useNTrees=0 );
115 void BoostMonitor(Int_t iTree);
117 public:
118 const std::vector<Float_t>& GetMulticlassValues();
120 // regression response
121 const std::vector<Float_t>& GetRegressionValues();
123 // apply the boost algorithm to a tree in the collection
124 Double_t Boost( std::vector<const TMVA::Event*>&, DecisionTree *dt, UInt_t cls = 0);
126 // ranking of input variables
127 const Ranking* CreateRanking();
129 // the option handling methods
130 void DeclareOptions();
131 void ProcessOptions();
133 void SetMinNodeSize(Double_t sizeInPercent);
134 void SetMinNodeSize(TString sizeInPercent);
144 // get the forest
145 inline const std::vector<TMVA::DecisionTree*> & GetForest() const;
147 // get the forest
148 inline const std::vector<const TMVA::Event*> & GetTrainingEvents() const;
150 inline const std::vector<double> & GetBoostWeights() const;
152 //return the individual relative variable importance
153 std::vector<Double_t> GetVariableImportance();
158 // make ROOT-independent C++ class for classifier response (classifier-specific implementation)
159 void MakeClassSpecific( std::ostream&, const TString& ) const;
161 // header and auxiliary classes
162 void MakeClassSpecificHeader( std::ostream&, const TString& ) const;
164 void MakeClassInstantiateNode( DecisionTreeNode *n, std::ostream& fout,
165 const TString& className ) const;
167 void GetHelpMessage() const;
169 protected:
172 private:
173 // Init used in the various constructors
174 void Init( void );
178 // boosting algorithm (adaptive boosting)
179 Double_t AdaBoost( std::vector<const TMVA::Event*>&, DecisionTree *dt );
181 // boosting algorithm (adaptive boosting with cost matrix)
182 Double_t AdaCost( std::vector<const TMVA::Event*>&, DecisionTree *dt );
184 // boosting as a random re-weighting
185 Double_t Bagging( );
187 // boosting special for regression
188 Double_t RegBoost( std::vector<const TMVA::Event*>&, DecisionTree *dt );
190 // adaboost adapted to regression
191 Double_t AdaBoostR2( std::vector<const TMVA::Event*>&, DecisionTree *dt );
193 // binomial likelihood gradient boost for classification
194 // (see Friedman: "Greedy Function Approximation: a Gradient Boosting Machine"
195 // Technical report, Dept. of Statistics, Stanford University)
196 Double_t GradBoost( std::vector<const TMVA::Event*>&, DecisionTree *dt, UInt_t cls = 0);
197 Double_t GradBoostRegression(std::vector<const TMVA::Event*>&, DecisionTree *dt );
198 void InitGradBoost( std::vector<const TMVA::Event*>&);
199 void UpdateTargets( std::vector<const TMVA::Event*>&, UInt_t cls = 0);
200 void UpdateTargetsRegression( std::vector<const TMVA::Event*>&,Bool_t first=kFALSE);
202 void GetBaggedSubSample(std::vector<const TMVA::Event*>&);
204 std::vector<const TMVA::Event*> fEventSample; // the training events
205 std::vector<const TMVA::Event*> fValidationSample;// the Validation events
206 std::vector<const TMVA::Event*> fSubSample; // subsample for bagged grad boost
207 std::vector<const TMVA::Event*> *fTrainSample; // pointer to sample actually used in training (fEventSample or fSubSample) for example
209 Int_t fNTrees; // number of decision trees requested
210 std::vector<DecisionTree*> fForest; // the collection of decision trees
211 std::vector<double> fBoostWeights; // the weights applied in the individual boosts
212 Double_t fSigToBkgFraction;// Signal to Background fraction assumed during training
213 TString fBoostType; // string specifying the boost type
214 Double_t fAdaBoostBeta; // beta parameter for AdaBoost algorithm
215 TString fAdaBoostR2Loss; // loss type used in AdaBoostR2 (Linear,Quadratic or Exponential)
216 //Double_t fTransitionPoint; // break-down point for gradient regression
217 Double_t fShrinkage; // learning rate for gradient boost;
218 Bool_t fBaggedBoost; // turn bagging in combination with boost on/off
219 Bool_t fBaggedGradBoost; // turn bagging in combination with grad boost on/off
220 //Double_t fSumOfWeights; // sum of all event weights
221 //std::map< const TMVA::Event*, std::pair<Double_t, Double_t> > fWeightedResiduals; // weighted regression residuals
222 std::map< const TMVA::Event*, LossFunctionEventInfo> fLossFunctionEventInfo; // map event to true value, predicted value, and weight
223 // used by different loss functions for BDT regression
224 std::map< const TMVA::Event*,std::vector<double> > fResiduals; // individual event residuals for gradient boost
226 //options for the decision Tree
227 SeparationBase *fSepType; // the separation used in node splitting
228 TString fSepTypeS; // the separation (option string) used in node splitting
229 Int_t fMinNodeEvents; // min number of events in node
230 Float_t fMinNodeSize; // min percentage of training events in node
231 TString fMinNodeSizeS; // string containing min percentage of training events in node
233 Int_t fNCuts; // grid used in cut applied in node splitting
234 Bool_t fUseFisherCuts; // use multivariate splits using the Fisher criterium
235 Double_t fMinLinCorrForFisher; // the minimum linear correlation between two variables demanded for use in fisher criterium in node splitting
236 Bool_t fUseExclusiveVars; // individual variables already used in fisher criterium are not anymore analysed individually for node splitting
237 Bool_t fUseYesNoLeaf; // use sig or bkg classification in leave nodes or sig/bkg
238 Double_t fNodePurityLimit; // purity limit for sig/bkg nodes
239 UInt_t fNNodesMax; // max # of nodes
240 UInt_t fMaxDepth; // max depth
242 DecisionTree::EPruneMethod fPruneMethod; // method used for prunig
243 TString fPruneMethodS; // prune method option String
244 Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted
245 Double_t fFValidationEvents; // fraction of events to use for pruning
246 Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample
247 Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training
248 UInt_t fUseNvars; // the number of variables used in the randomised tree splitting
249 Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number but as mean of a possion distr. in each split
250 UInt_t fUseNTrainEvents; // number of randomly picked training events used in randomised (and bagged) trees
252 Double_t fBaggedSampleFraction; // relative size of bagged event sample to original sample size
253 TString fNegWeightTreatment; // variable that holds the option of how to treat negative event weights in training
254 Bool_t fNoNegWeightsInTraining; // ignore negative event weights in the training
255 Bool_t fInverseBoostNegWeights; // boost ev. with neg. weights with 1/boostweight rathre than boostweight
256 Bool_t fPairNegWeightsGlobal; // pair ev. with neg. and pos. weights in traning sample and "annihilate" them
257 Bool_t fTrainWithNegWeights; // yes there are negative event weights and we don't ignore them
258 Bool_t fDoBoostMonitor; //create control plot with ROC integral vs tree number
261 //some histograms for monitoring
262 TTree* fMonitorNtuple; // monitoring ntuple
263 Int_t fITree; // ntuple var: ith tree
264 Double_t fBoostWeight; // ntuple var: boost weight
265 Double_t fErrorFraction; // ntuple var: misclassification error fraction
267 Double_t fCss; // Cost factor
268 Double_t fCts_sb; // Cost factor
269 Double_t fCtb_ss; // Cost factor
270 Double_t fCbb; // Cost factor
272 Bool_t fDoPreselection; // do or do not perform automatic pre-selection of 100% eff. cuts
274 Bool_t fSkipNormalization; // true for skipping normalization at initialization of trees
276 std::vector<Double_t> fVariableImportance; // the relative importance of the different variables
279 void DeterminePreselectionCuts(const std::vector<const TMVA::Event*>& eventSample);
282 std::vector<Double_t> fLowSigCut;
283 std::vector<Double_t> fLowBkgCut;
284 std::vector<Double_t> fHighSigCut;
285 std::vector<Double_t> fHighBkgCut;
287 std::vector<Bool_t> fIsLowSigCut;
288 std::vector<Bool_t> fIsLowBkgCut;
289 std::vector<Bool_t> fIsHighSigCut;
290 std::vector<Bool_t> fIsHighBkgCut;
292 Bool_t fHistoricBool; //historic variable, only needed for "CompatibilityOptions"
294 TString fRegressionLossFunctionBDTGS; // the option string determining the loss function for BDT regression
295 Double_t fHuberQuantile; // the option string determining the quantile for the Huber Loss Function
296 // in BDT regression.
299 // debugging flags
300 static const Int_t fgDebugLevel; // debug level determining some printout/control plots etc.
302 // for backward compatibility
303 ClassDef(MethodBDT,0); // Analysis of Boosted Decision Trees
304 };
306} // namespace TMVA
308const std::vector<TMVA::DecisionTree*>& TMVA::MethodBDT::GetForest() const { return fForest; }
309const std::vector<const TMVA::Event*> & TMVA::MethodBDT::GetTrainingEvents() const { return fEventSample; }
310const std::vector<double>& TMVA::MethodBDT::GetBoostWeights() const { return fBoostWeights; }
#define d(i)
Definition: RSha256.hxx:102
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define e(i)
Definition: RSha256.hxx:103
unsigned int UInt_t
Definition: RtypesCore.h:44
const Bool_t kFALSE
Definition: RtypesCore.h:90
bool Bool_t
Definition: RtypesCore.h:61
double Double_t
Definition: RtypesCore.h:57
float Float_t
Definition: RtypesCore.h:55
#define ClassDef(name, id)
Definition: Rtypes.h:322
int type
Definition: TGX11.cxx:120
Class that contains all the data information.
Definition: DataSetInfo.h:60
Implementation of a Decision Tree.
Definition: DecisionTree.h:64
Analysis of Boosted Decision Trees.
Definition: MethodBDT.h:61
Double_t fCbb
Definition: MethodBDT.h:270
std::vector< Double_t > fHighBkgCut
Definition: MethodBDT.h:285
void SetBaggedSampleFraction(Double_t f)
Definition: MethodBDT.h:141
Bool_t fBaggedGradBoost
Definition: MethodBDT.h:219
DecisionTree::EPruneMethod fPruneMethod
Definition: MethodBDT.h:242
std::vector< const TMVA::Event * > fEventSample
Definition: MethodBDT.h:204
void Init(void)
Common initialisation with defaults for the BDT-Method.
Definition: MethodBDT.cxx:688
Double_t fHuberQuantile
Definition: MethodBDT.h:295
static const Int_t fgDebugLevel
Definition: MethodBDT.h:300
MethodBDT(const TString &jobName, const TString &methodTitle, DataSetInfo &theData, const TString &theOption="")
The standard constructor for the "boosted decision trees".
Definition: MethodBDT.cxx:164
Bool_t fBaggedBoost
Definition: MethodBDT.h:218
TString fMinNodeSizeS
Definition: MethodBDT.h:231
void BoostMonitor(Int_t iTree)
Fills the ROCIntegral vs Itree from the testSample for the monitoring plots during the training .
Definition: MethodBDT.cxx:1753
const std::vector< Float_t > & GetMulticlassValues()
Get the multiclass MVA response for the BDT classifier.
Definition: MethodBDT.cxx:2496
std::map< const TMVA::Event *, LossFunctionEventInfo > fLossFunctionEventInfo
Definition: MethodBDT.h:222
std::vector< const TMVA::Event * > * fTrainSample
Definition: MethodBDT.h:207
std::vector< Bool_t > fIsHighSigCut
Definition: MethodBDT.h:289
Double_t AdaBoostR2(std::vector< const TMVA::Event * > &, DecisionTree *dt)
Adaption of the AdaBoost to regression problems (see H.Drucker 1997).
Definition: MethodBDT.cxx:2194
void MakeClassSpecific(std::ostream &, const TString &) const
Make ROOT-independent C++ class for classifier response (classifier-specific implementation).
Definition: MethodBDT.cxx:2758
Bool_t fPairNegWeightsGlobal
Definition: MethodBDT.h:256
Bool_t fSkipNormalization
Definition: MethodBDT.h:274
Bool_t fUseExclusiveVars
Definition: MethodBDT.h:236
UInt_t fUseNvars
Definition: MethodBDT.h:248
Double_t fCts_sb
Definition: MethodBDT.h:268
void GetHelpMessage() const
Get help message text.
Definition: MethodBDT.cxx:2701
LossFunctionBDT * fRegressionLossFunctionBDTG
Definition: MethodBDT.h:297
void DeterminePreselectionCuts(const std::vector< const TMVA::Event * > &eventSample)
Find useful preselection cuts that will be applied before and Decision Tree training.
Definition: MethodBDT.cxx:3037
void SetNTrees(Int_t d)
Definition: MethodBDT.h:136
Double_t GradBoost(std::vector< const TMVA::Event * > &, DecisionTree *dt, UInt_t cls=0)
Calculate the desired response value for each region.
Definition: MethodBDT.cxx:1596
const Ranking * CreateRanking()
Compute ranking of input variables.
Definition: MethodBDT.cxx:2684
virtual void SetTuneParameters(std::map< TString, Double_t > tuneParameters)
Set the tuning parameters according to the argument.
Definition: MethodBDT.cxx:1122
void SetAdaBoostBeta(Double_t b)
Definition: MethodBDT.h:137
Bool_t fUsePoissonNvars
Definition: MethodBDT.h:249
Float_t fMinNodeSize
Definition: MethodBDT.h:230
Bool_t fDoBoostMonitor
Definition: MethodBDT.h:258
Double_t AdaCost(std::vector< const TMVA::Event * > &, DecisionTree *dt)
The AdaCost boosting algorithm takes a simple cost Matrix (currently fixed for all events....
Definition: MethodBDT.cxx:2025
void DeclareOptions()
Define the options (their key words).
Definition: MethodBDT.cxx:334
Bool_t fTrainWithNegWeights
Definition: MethodBDT.h:257
TString fRegressionLossFunctionBDTGS
Definition: MethodBDT.h:294
std::vector< double > fBoostWeights
Definition: MethodBDT.h:211
Bool_t fDoPreselection
Definition: MethodBDT.h:272
std::vector< Double_t > fVariableImportance
Definition: MethodBDT.h:276
Int_t fMinNodeEvents
Definition: MethodBDT.h:229
std::vector< Bool_t > fIsLowBkgCut
Definition: MethodBDT.h:288
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: MethodBDT.cxx:1069
Double_t Boost(std::vector< const TMVA::Event * > &, DecisionTree *dt, UInt_t cls=0)
Apply the boosting algorithm (the algorithm is selecte via the the "option" given in the constructor.
Definition: MethodBDT.cxx:1719
Double_t TestTreeQuality(DecisionTree *dt)
Test the tree quality.. in terms of Misclassification.
Definition: MethodBDT.cxx:1698
std::vector< DecisionTree * > fForest
Definition: MethodBDT.h:210
std::vector< Bool_t > fIsLowSigCut
Definition: MethodBDT.h:287
UInt_t GetNTrees() const
Definition: MethodBDT.h:110
Double_t Bagging()
Call it boot-strapping, re-sampling or whatever you like, in the end it is nothing else but applying ...
Definition: MethodBDT.cxx:2141
Double_t fErrorFraction
Definition: MethodBDT.h:265
Bool_t fRandomisedTrees
Definition: MethodBDT.h:247
Double_t fBaggedSampleFraction
Definition: MethodBDT.h:252
Double_t fCss
Definition: MethodBDT.h:267
Bool_t fUseFisherCuts
Definition: MethodBDT.h:234
Double_t fPruneStrength
Definition: MethodBDT.h:244
const std::vector< double > & GetBoostWeights() const
Definition: MethodBDT.h:310
void SetMaxDepth(Int_t d)
Definition: MethodBDT.h:132
void UpdateTargets(std::vector< const TMVA::Event * > &, UInt_t cls=0)
Calculate residual for all events.
Definition: MethodBDT.cxx:1436
Double_t fFValidationEvents
Definition: MethodBDT.h:245
std::vector< const TMVA::Event * > fSubSample
Definition: MethodBDT.h:206
void UpdateTargetsRegression(std::vector< const TMVA::Event * > &, Bool_t first=kFALSE)
Calculate residuals for all events and update targets for next iter.
Definition: MethodBDT.cxx:1558
Double_t GradBoostRegression(std::vector< const TMVA::Event * > &, DecisionTree *dt)
Implementation of M_TreeBoost using any loss function as described by Friedman 1999.
Definition: MethodBDT.cxx:1630
void WriteMonitoringHistosToFile(void) const
Here we could write some histograms created during the processing to the output file.
Definition: MethodBDT.cxx:2629
std::vector< Double_t > fLowBkgCut
Definition: MethodBDT.h:283
UInt_t fMaxDepth
Definition: MethodBDT.h:240
void SetShrinkage(Double_t s)
Definition: MethodBDT.h:139
TString fAdaBoostR2Loss
Definition: MethodBDT.h:215
virtual ~MethodBDT(void)
Definition: MethodBDT.cxx:754
void AddWeightsXMLTo(void *parent) const
Write weights to XML.
Definition: MethodBDT.cxx:2311
Double_t GetGradBoostMVA(const TMVA::Event *e, UInt_t nTrees)
Returns MVA value: -1 for background, 1 for signal.
Definition: MethodBDT.cxx:1422
TString fPruneMethodS
Definition: MethodBDT.h:243
Double_t fNodePurityLimit
Definition: MethodBDT.h:238
virtual Bool_t HasAnalysisType(Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
BDT can handle classification with multiple classes and regression with one regression-target.
Definition: MethodBDT.cxx:281
Double_t fShrinkage
Definition: MethodBDT.h:217
void SetNodePurityLimit(Double_t l)
Definition: MethodBDT.h:138
TString fSepTypeS
Definition: MethodBDT.h:228
Double_t RegBoost(std::vector< const TMVA::Event * > &, DecisionTree *dt)
A special boosting only for Regression (not implemented).
Definition: MethodBDT.cxx:2186
void InitEventSample()
Initialize the event sample (i.e. reset the boost-weights... etc).
Definition: MethodBDT.cxx:762
Double_t ApplyPreselectionCuts(const Event *ev)
Apply the preselection cuts before even bothering about any Decision Trees in the GetMVA .
Definition: MethodBDT.cxx:3137
void SetMinNodeSize(Double_t sizeInPercent)
Definition: MethodBDT.cxx:661
Bool_t fHistoricBool
Definition: MethodBDT.h:292
Double_t fBoostWeight
Definition: MethodBDT.h:264
void ProcessOptions()
The option string is decoded, for available options see "DeclareOptions".
Definition: MethodBDT.cxx:471
void PreProcessNegativeEventWeights()
Definition: MethodBDT.cxx:933
Bool_t fUseYesNoLeaf
Definition: MethodBDT.h:237
std::vector< const TMVA::Event * > fValidationSample
Definition: MethodBDT.h:205
Bool_t fAutomatic
Definition: MethodBDT.h:246
std::vector< Double_t > fLowSigCut
Definition: MethodBDT.h:282
Bool_t fInverseBoostNegWeights
Definition: MethodBDT.h:255
Double_t fCtb_ss
Definition: MethodBDT.h:269
std::map< const TMVA::Event *, std::vector< double > > fResiduals
Definition: MethodBDT.h:224
UInt_t fNNodesMax
Definition: MethodBDT.h:239
void MakeClassInstantiateNode(DecisionTreeNode *n, std::ostream &fout, const TString &className) const
Recursively descends a tree and writes the node instance to the output stream.
Definition: MethodBDT.cxx:2992
Double_t AdaBoost(std::vector< const TMVA::Event * > &, DecisionTree *dt)
The AdaBoost implementation.
Definition: MethodBDT.cxx:1847
TTree * fMonitorNtuple
Definition: MethodBDT.h:262
std::vector< Double_t > GetVariableImportance()
Return the relative variable importance, normalized to all variables together having the importance 1...
Definition: MethodBDT.cxx:2644
void SetUseNvars(Int_t n)
Definition: MethodBDT.h:140
Double_t GetMvaValue(Double_t *err=0, Double_t *errUpper=0)
Definition: MethodBDT.cxx:2444
Bool_t fNoNegWeightsInTraining
Definition: MethodBDT.h:254
Double_t fAdaBoostBeta
Definition: MethodBDT.h:214
Double_t PrivateGetMvaValue(const TMVA::Event *ev, Double_t *err=0, Double_t *errUpper=0, UInt_t useNTrees=0)
Return the MVA value (range [-1;1]) that classifies the event according to the majority vote from the...
Definition: MethodBDT.cxx:2469
void InitGradBoost(std::vector< const TMVA::Event * > &)
Initialize targets for first tree.
Definition: MethodBDT.cxx:1659
void Train(void)
BDT training.
Definition: MethodBDT.cxx:1143
const std::vector< TMVA::DecisionTree * > & GetForest() const
Definition: MethodBDT.h:308
void GetBaggedSubSample(std::vector< const TMVA::Event * > &)
Fills fEventSample with fBaggedSampleFraction*NEvents random training events.
Definition: MethodBDT.cxx:2152
const std::vector< const TMVA::Event * > & GetTrainingEvents() const
Definition: MethodBDT.h:309
const std::vector< Float_t > & GetRegressionValues()
Get the regression value generated by the BDTs.
Definition: MethodBDT.cxx:2543
std::vector< Double_t > fHighSigCut
Definition: MethodBDT.h:284
SeparationBase * fSepType
Definition: MethodBDT.h:227
void ReadWeightsFromXML(void *parent)
Reads the BDT from the xml file.
Definition: MethodBDT.cxx:2342
void ReadWeightsFromStream(std::istream &istr)
Read the weights (BDT coefficients).
Definition: MethodBDT.cxx:2409
TString fNegWeightTreatment
Definition: MethodBDT.h:253
std::vector< Bool_t > fIsHighBkgCut
Definition: MethodBDT.h:290
void Reset(void)
Reset the method, as if it had just been instantiated (forget all training etc.).
Definition: MethodBDT.cxx:726
Double_t fSigToBkgFraction
Definition: MethodBDT.h:212
void MakeClassSpecificHeader(std::ostream &, const TString &) const
Specific class header.
Definition: MethodBDT.cxx:2878
Double_t fMinLinCorrForFisher
Definition: MethodBDT.h:235
UInt_t fUseNTrainEvents
Definition: MethodBDT.h:250
TString fBoostType
Definition: MethodBDT.h:213
void DeclareCompatibilityOptions()
Options that are used ONLY for the READER to ensure backward compatibility.
Definition: MethodBDT.cxx:455
Virtual base Class for all MVA method.
Definition: MethodBase.h:111
virtual void ReadWeightsFromStream(std::istream &)=0
Ranking for variables in method (implementation)
Definition: Ranking.h:48
An interface to calculate the "SeparationGain" for different separation criteria used in various trai...
Definition: Types.h:127
Basic string class.
Definition: TString.h:131
A TTree represents a columnar dataset.
Definition: TTree.h:78
const Int_t n
Definition: legend1.C:16
static constexpr double s
create variable transformations
Definition: first.py:1
auto * l
Definition: textangle.C:4