library: libTMVA
#include "MethodBDT.h"

TMVA::MethodBDT


class description - header file - source file
viewCVS header - viewCVS source

class TMVA::MethodBDT: public TMVA::MethodBase

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
virtual~MethodBDT()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual Double_tBoost(vector<TMVA::Event*,allocator<TMVA::Event*> >, TMVA::DecisionTree* dt, Int_t iTree)
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual const TMVA::Ranking*CreateRanking()
TMVA::DataSet&TMVA::MethodBase::Data() const
virtual voidDeclareOptions()
virtual voidTObject::Delete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
const vector<double>&GetBoostWeights() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Double_tTMVA::MethodBase::GetEffForRoot(Double_t)
virtual Double_tTMVA::MethodBase::GetEfficiency(TString, TTree*)
Double_tTMVA::MethodBase::GetEventVal(Int_t ivar) const
Double_tTMVA::MethodBase::GetEventValNormalized(Int_t ivar) const
Double_tTMVA::MethodBase::GetEventWeight() const
const vector<TMVA::DecisionTree*>&GetForest() const
virtual const char*TObject::GetIconName() const
const TString&TMVA::MethodBase::GetInputExp(int i) const
const TString&TMVA::MethodBase::GetInputVar(int i) const
virtual const TString&TMVA::MethodBase::GetJobName() const
virtual const TString&TMVA::MethodBase::GetMethodName() const
virtual const TString&TMVA::MethodBase::GetMethodTitle() const
virtual const TMVA::Types::EMVATMVA::MethodBase::GetMethodType() const
virtual Double_tTMVA::MethodBase::GetmuTransform(TTree*)
virtual Double_tGetMvaValue()
virtual const char*TMVA::MethodBase::GetName() const
Int_tTMVA::MethodBase::GetNvar() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Double_tTMVA::MethodBase::GetOptimalSignificance(Double_t SignalEvents, Double_t BackgroundEvents, Double_t& optimal_significance_value) const
virtual Option_t*TObject::GetOption() const
TStringTMVA::MethodBase::GetOptions() const
virtual TMVA::Types::EPreprocessingMethodTMVA::MethodBase::GetPreprocessingMethod() const
virtual Double_tTMVA::MethodBase::GetSeparation()
virtual Double_tTMVA::MethodBase::GetSignificance()
TTree*TMVA::MethodBase::GetTestTree() const
static TMVA::MethodBase*TMVA::MethodBase::GetThisBase()
virtual const char*TObject::GetTitle() const
virtual Double_tTMVA::MethodBase::GetTrainingEfficiency(TString)
const vector<TMVA::Event*>&GetTrainingEvents() const
TTree*TMVA::MethodBase::GetTrainingTree() const
virtual UInt_tTObject::GetUniqueID() const
vector<Double_t>GetVariableImportance()
Double_tGetVariableImportance(UInt_t ivar)
virtual TStringTMVA::MethodBase::GetWeightFileDir() const
virtual TStringTMVA::MethodBase::GetWeightFileExtension() const
TStringTMVA::MethodBase::GetWeightFileName() const
TMVA::MethodBase::EWeightFileTypeTMVA::MethodBase::GetWeightFileType() const
Double_tTMVA::MethodBase::GetXmax(Int_t ivar, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmax(const TString& var, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmin(Int_t ivar, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
Double_tTMVA::MethodBase::GetXmin(const TString& var, TMVA::Types::EPreprocessingMethod corr = Types::kNone) const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
Bool_tTMVA::MethodBase::HasTrainingTree() const
static Double_tTMVA::MethodBase::IGetEffForRoot(Double_t)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidInitEventSample()
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tTMVA::MethodBase::IsOK() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTMVA::MethodBase::IsSignalLike()
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
TMVA::MethodBDTMethodBDT(TMVA::DataSet& theData, TString theWeightFile, TDirectory* theTargetDir = NULL)
TMVA::MethodBDTMethodBDT(TString jobName, TString methodTitle, TMVA::DataSet& theData, TString theOption = , TDirectory* theTargetDir = 0)
Double_tTMVA::MethodBase::Norm(Int_t ivar, Double_t x) const
Double_tTMVA::MethodBase::Norm(TString var, Double_t x) const
virtual Bool_tTObject::Notify()
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TMVA::IMethod&TMVA::IMethod::operator=(const TMVA::IMethod&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTMVA::MethodBase::PrepareEvaluationTree(TTree* theTestTree)
virtual voidTObject::Print(Option_t* option = "") const
virtual voidProcessOptions()
Double_tPruneTree(TMVA::DecisionTree* dt, Int_t itree)
virtual Int_tTObject::Read(const char* name)
virtual voidTMVA::MethodBase::ReadStateFromFile()
virtual voidTMVA::MethodBase::ReadStateFromStream(istream& i)
virtual Bool_tTMVA::MethodBase::ReadTestEvent(UInt_t ievt, TMVA::Types::ESBType type = Types::kMaxSBType)
Bool_tTMVA::MethodBase::ReadTrainingEvent(UInt_t ievt, TMVA::Types::ESBType type = Types::kMaxSBType)
virtual voidReadWeightsFromStream(istream& istr)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
virtual voidTMVA::MethodBase::SetJobName(TString jobName)
voidTMVA::MethodBase::SetMethodName(TString methodName)
voidTMVA::MethodBase::SetMethodTitle(TString methodTitle)
voidTMVA::MethodBase::SetMethodType(TMVA::Types::EMVA methodType)
voidTMVA::MethodBase::SetNvar(Int_t n)
static voidTObject::SetObjectStat(Bool_t stat)
voidTMVA::MethodBase::SetPreprocessingMethod(TMVA::Types::EPreprocessingMethod m)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTMVA::MethodBase::SetVerbose(Bool_t v = kTRUE)
virtual voidTMVA::MethodBase::SetWeightFileDir(TString fileDir)
virtual voidTMVA::MethodBase::SetWeightFileExtension(TString fileExtension)
voidTMVA::MethodBase::SetWeightFileName(TString)
voidTMVA::MethodBase::SetWeightFileType(TMVA::MethodBase::EWeightFileType w)
voidTMVA::MethodBase::SetXmax(Int_t ivar, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmax(const TString& var, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmin(Int_t ivar, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
voidTMVA::MethodBase::SetXmin(const TString& var, Double_t x, TMVA::Types::EPreprocessingMethod corr = Types::kNone)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTMVA::MethodBase::Test(TTree* theTestTree = 0)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTMVA::MethodBase::TestInit(TTree* theTestTree = 0)
Double_tTestTreeQuality(TMVA::DecisionTree* dt)
virtual voidTrain()
voidTMVA::MethodBase::TrainMethod()
virtual voidTObject::UseCurrentStyle()
Bool_tTMVA::MethodBase::Verbose() const
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = "0", Int_t option = 0, Int_t bufsize = 0) const
virtual voidTMVA::MethodBase::WriteEvaluationHistosToFile(TDirectory* targetDir)
virtual voidWriteMonitoringHistosToFile() const
voidTMVA::MethodBase::WriteStateToFile() const
virtual voidTMVA::MethodBase::WriteStateToStream(ostream& o) const
virtual voidWriteWeightsToStream(ostream& o) const
protected:
TDirectory*TMVA::MethodBase::BaseDir() const
Bool_tTMVA::MethodBase::CheckSanity(TTree* theTree = 0)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTMVA::MethodBase::EnableLooseOptions(Bool_t b = kTRUE)
TMVA::MethodBase::ECutOrientationTMVA::MethodBase::GetCutOrientation() const
TMVA::Types::ESBTypeTMVA::MethodBase::GetPreprocessingType() const
Double_tTMVA::MethodBase::GetSignalReferenceCut() const
const TString&TMVA::MethodBase::GetTestvarName() const
const TString&TMVA::MethodBase::GetTestvarPrefix() const
const TList&TMVA::MethodBase::ListOfOptions() const
TDirectory*TMVA::MethodBase::LocalTDir() const
voidTObject::MakeZombie()
voidTMVA::MethodBase::ParseOptions(Bool_t verbose = kTRUE)
voidTMVA::MethodBase::PrintOptions() const
voidTMVA::MethodBase::ReadOptionsFromStream(istream& istr)
voidTMVA::MethodBase::ResetThisBase()
voidTMVA::MethodBase::SetPreprocessingType(TMVA::Types::ESBType t)
voidTMVA::MethodBase::SetSignalReferenceCut(Double_t cut)
voidTMVA::MethodBase::SetTestvarName()
voidTMVA::MethodBase::SetTestvarName(TString v)
voidTMVA::MethodBase::SetTestvarPrefix(TString prefix)
voidTMVA::MethodBase::Statistics(TMVA::Types::ETreeType treeType, const TString& theVarName, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Bool_t norm = kFALSE)
voidTMVA::MethodBase::WriteOptionsToStream(ostream& o) const
private:
Double_tAdaBoost(vector<TMVA::Event*,allocator<TMVA::Event*> >, TMVA::DecisionTree* dt)
Double_tBagging(vector<TMVA::Event*,allocator<TMVA::Event*> >, Int_t iTree)
voidInitBDT()

Data Members

public:
enum TMVA::MethodBase::EWeightFileType { kROOT
kTEXT
};
enum TMVA::MethodBase::ECutOrientation { kNegative
kPositive
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TMVA::Ranking*TMVA::MethodBase::fRankingranking
vector<TString>*TMVA::MethodBase::fInputVarsvector of input variables used in MVA
Bool_tTMVA::MethodBase::fIsOKstatus of sanity checks
TH1*TMVA::MethodBase::fHistS_plotbinMVA plots used for graphics representation (signal)
TH1*TMVA::MethodBase::fHistB_plotbinMVA plots used for graphics representation (background)
TH1*TMVA::MethodBase::fHistS_highbinMVA plots used for efficiency calculations (signal)
TH1*TMVA::MethodBase::fHistB_highbinMVA plots used for efficiency calculations (background)
TH1*TMVA::MethodBase::fEffSefficiency plot (signal)
TH1*TMVA::MethodBase::fEffBefficiency plot (background)
TH1*TMVA::MethodBase::fEffBvsSbackground efficiency versus signal efficiency
TH1*TMVA::MethodBase::fRejBvsSbackground rejection (=1-eff.) versus signal efficiency
TH1*TMVA::MethodBase::fHistBhatSworking histograms needed for mu-transform (signal)
TH1*TMVA::MethodBase::fHistBhatBworking histograms needed for mu-transform (background)
TH1*TMVA::MethodBase::fHistMuSmu-transform (signal)
TH1*TMVA::MethodBase::fHistMuBmu-transform (background)
TH1*TMVA::MethodBase::fTrainEffSTraining efficiency plot (signal)
TH1*TMVA::MethodBase::fTrainEffBTraining efficiency plot (background)
TH1*TMVA::MethodBase::fTrainEffBvsSTraining background efficiency versus signal efficiency
TH1*TMVA::MethodBase::fTrainRejBvsSTraining background rejection (=1-eff.) versus signal efficiency
Double_tTMVA::MethodBase::fX
Double_tTMVA::MethodBase::fMode
TGraph*TMVA::MethodBase::fGraphSgraphs used for splines for efficiency (signal)
TGraph*TMVA::MethodBase::fGraphBgraphs used for splines for efficiency (background)
TGraph*TMVA::MethodBase::fGrapheffBvsSgraphs used for splines for signal eff. versus background eff.
TMVA::PDF*TMVA::MethodBase::fSplSPDFs of MVA distribution (signal)
TMVA::PDF*TMVA::MethodBase::fSplBPDFs of MVA distribution (background)
TSpline*TMVA::MethodBase::fSpleffBvsSsplines for signal eff. versus background eff.
TGraph*TMVA::MethodBase::fGraphTrainSgraphs used for splines for training efficiency (signal)
TGraph*TMVA::MethodBase::fGraphTrainBgraphs used for splines for training efficiency (background)
TGraph*TMVA::MethodBase::fGraphTrainEffBvsSgraphs used for splines for training signal eff. versus background eff.
TMVA::PDF*TMVA::MethodBase::fSplTrainSPDFs of training MVA distribution (signal)
TMVA::PDF*TMVA::MethodBase::fSplTrainBPDFs of training MVA distribution (background)
TSpline*TMVA::MethodBase::fSplTrainEffBvsSsplines for training signal eff. versus background eff.
Int_tTMVA::MethodBase::fNbinsnumber of bins in representative histograms
Int_tTMVA::MethodBase::fNbinsHnumber of bins in evaluation histograms
TMVA::MethodBase::ECutOrientationTMVA::MethodBase::fCutOrientation+1 if Sig>Bkg, -1 otherwise
TMVA::TSpline1*TMVA::MethodBase::fSplRefShelper splines for RootFinder (signal)
TMVA::TSpline1*TMVA::MethodBase::fSplRefBhelper splines for RootFinder (background)
TMVA::TSpline1*TMVA::MethodBase::fSplTrainRefShelper splines for RootFinder (signal)
TMVA::TSpline1*TMVA::MethodBase::fSplTrainRefBhelper splines for RootFinder (background)
TMVA::OptionBase*TMVA::MethodBase::fLastDeclaredOptionlast declared option
TListTMVA::MethodBase::fListOfOptionsoption list
TMVA::MsgLoggerTMVA::MethodBase::fLoggermessage logger
private:
vector<TMVA::Event*,allocator<TMVA::Event*> >fEventSamplethe training events
vector<TMVA::Event*,allocator<TMVA::Event*> >fValidationSamplethe Validation events
Int_tfNTreesnumber of decision trees requested
vector<DecisionTree*>fForestthe collection of decision trees
vector<double>fBoostWeightsthe weights applied in the individual boosts
TStringfBoostTypestring specifying the boost type
TMVA::SeparationBase*fSepTypethe separation used in node splitting
TStringfSepTypeSthe separation (option string) used in node splitting
Int_tfNodeMinEventsmin number of events in node
Int_tfNCutsgrid used in cut applied in node splitting
Bool_tfUseYesNoLeafuse sig or bkg classification in leave nodes or sig/bkg
Bool_tfUseWeightedTreesuse average classification from the trees, or have the individual trees trees in the forest weighted (e.g. log(boostweight) from AdaBoost
TH1F*fBoostWeightHistweights applied in boosting
TH1F*fBoostWeightVsTreeweights applied in boosting vs tree number
TH1F*fErrFractHisterror fraction vs tree number
TH1I*fNodesBeforePruningVsTreenNodesBeforePruning vs tree number
TH1I*fNodesAfterPruningVsTreenNodesAfterPruning vs tree number
TTree*fMonitorNtuplemonitoring ntuple
Int_tfITreentuple var: ith tree
Double_tfBoostWeightntuple var: boost weight
Double_tfErrorFractionntuple var: misclassification error fraction
Double_tfPruneStrengtha parameter to set the "amount" of pruning..needs to be adjusted
TMVA::DecisionTree::EPruneMethodfPruneMethodmethod used for prunig
TStringfPruneMethodSprune method option String
Bool_tfAutomaticuse user given prune strength or automatically determined one using a validation sample
vector<Double_t>fVariableImportancethe relative importance of the different variables
Double_tfDeltaPruneStrengthstep size in pruning, is adjusted according to experience of previous trees
static const Int_tfgDebugLeveldebug level determining some printout/control plots etc.

Class Description

                                                                      
 Analysis of Boosted Decision Trees                                   
               
 Boosted decision trees have been successfully used in High Energy 
 Physics analysis for example by the MiniBooNE experiment
 (Yang-Roe-Zhu, physics/0508045). In Boosted Decision Trees, the
 selection is done on a majority vote on the result of several decision
 trees, which are all derived from the same training sample by
 supplying different event weights during the training.

 Decision trees: 

 successive decision nodes are used to categorize the
 events out of the sample as either signal or background. Each node
 uses only a single discriminating variable to decide if the event is
 signal-like ("goes right") or background-like ("goes left"). This
 forms a tree like structure with "baskets" at the end (leave nodes),
 and an event is classified as either signal or background according to
 whether the basket where it ends up has been classified signal or
 background during the training. Training of a decision tree is the
 process to define the "cut criteria" for each node. The training
 starts with the root node. Here one takes the full training event
 sample and selects the variable and corresponding cut value that gives
 the best separation between signal and background at this stage. Using
 this cut criterion, the sample is then divided into two subsamples, a
 signal-like (right) and a background-like (left) sample. Two new nodes
 are then created for each of the two sub-samples and they are
 constructed using the same mechanism as described for the root
 node. The devision is stopped once a certain node has reached either a
 minimum number of events, or a minimum or maximum signal purity. These
 leave nodes are then called "signal" or "background" if they contain
 more signal respective background events from the training sample.

 Boosting: 

 the idea behind the boosting is, that signal events from the training
 sample, that end up in a background node (and vice versa) are given a
 larger weight than events that are in the correct leave node. This
 results in a re-weighed training event sample, with which then a new
 decision tree can be developed. The boosting can be applied several
 times (typically 100-500 times) and one ends up with a set of decision
 trees (a forest).

 Bagging: 

 In this particular variant of the Boosted Decision Trees the boosting
 is not done on the basis of previous training results, but by a simple
 stochasitc re-sampling of the initial training event sample.

 Analysis: 

 applying an individual decision tree to a test event results in a
 classification of the event as either signal or background. For the
 boosted decision tree selection, an event is successively subjected to
 the whole set of decision trees and depending on how often it is
 classified as signal, a "likelihood" estimator is constructed for the
 event being signal or background. The value of this estimator is the
 one which is then used to select the events from an event sample, and
 the cut value on this estimator defines the efficiency and purity of
 the selection.

_______________________________________________________________________
MethodBDT( TString jobName, TString methodTitle, DataSet& theData, TString theOption, TDirectory* theTargetDir )
 the standard constructor for the "boosted decision trees" 

 MethodBDT (Boosted Decision Trees) options:
 know options:
 nTrees=Int_t:    number of trees in the forest to be created
 BoostType=       the boosting type for the trees in the forest (AdaBoost e.t.c..)
                  known: AdaBoost
                         Bagging
 SeparationType   the separation criterion applied in the node splitting
                  known: GiniIndex
                         MisClassificationError
                         CrossEntropy
                         SDivSqrtSPlusB
 nEventsMin:      the minimum number of events in a node (leaf criteria, stop splitting)
 nCuts:           the number of steps in the optimisation of the cut for a node
 UseYesNoLeaf     decide if the classification is done simply by the node type, or the S/B
                  (from the training) in the leaf node
 UseWeightedTrees use average classification from the trees, or have the individual trees
                  trees in the forest weighted (e.g. log(boostweight) from AdaBoost
 PruneMethod      The Pruning method: 
                  known: ExpectedError
                         CostComplexity 
                         CostComplexity2
 PruneStrength    a parameter to adjust the amount of pruning. Should be large enouth such that overtraining is avoided");
MethodBDT( DataSet& theData, TString theWeightFile, TDirectory* theTargetDir )
 constructor for calculating BDT-MVA using previously generatad decision trees
 the result of the previous training (the decision trees) are read in via the
 weightfile. Make sure the "theVariables" correspond to the ones used in 
 creating the "weight"-file
void DeclareOptions()
 define the options (their key words) that can be set in the option string 
 know options:
 nTrees=Int_t:    number of trees in the forest to be created
 BoostType=       the boosting type for the trees in the forest (AdaBoost e.t.c..)
                  known: AdaBoost
                         Bagging
 SeparationType   the separation criterion applied in the node splitting
                  known: GiniIndex
                         MisClassificationError
                         CrossEntropy
                         SDivSqrtSPlusB
 nEventsMin:      the minimum number of events in a node (leaf criteria, stop splitting)
 nCuts:           the number of steps in the optimisation of the cut for a node
 UseYesNoLeaf     decide if the classification is done simply by the node type, or the S/B
                  (from the training) in the leaf node
 UseWeightedTrees use average classification from the trees, or have the individual trees
                  trees in the forest weighted (e.g. log(boostweight) from AdaBoost
 PruneMethod      The Pruning method: 
                  known: ExpectedError
                         CostComplexity 
                         CostComplexity2
 PruneStrength    a parameter to adjust the amount of pruning. Should be large enouth such that overtraining is avoided");
void ProcessOptions()
 the option string is decoded, for available options see "DeclareOptions"
void InitBDT( void )
 common initialisation with defaults for the BDT-Method
~MethodBDT( void )
destructor
void InitEventSample( void )
 write all Events from the Tree into a vector of TMVA::Events, that are 
 more easily manipulated.  
 This method should never be called without existing trainingTree, as it
 the vector of events from the ROOT training tree
void Train( void )
 default sanity checks
Double_t PruneTree( TMVA::DecisionTree *dt, Int_t itree)
 prune a tree adjusting the prunestrength using the "test sample" until
 the best efficiency on the test sample is obtained. In principle the
 test sample should not be used for that but rather a third validation
 sample, or the trainng sample with "cross validation". The latter is
 planned but will come later.
Double_t TestTreeQuality( TMVA::DecisionTree *dt )
 test the tree quality.. in terms of Miscalssification
 
Double_t Boost( vector<TMVA::Event*> eventSample, TMVA::DecisionTree *dt, Int_t iTree )
 apply the boosting alogrithim (the algorithm is selecte via the the "option" given
 in the constructor. The return value is the boosting weight 
Double_t AdaBoost( vector<TMVA::Event*> eventSample, TMVA::DecisionTree *dt )
 the AdaBoost implementation.
 a new training sample is generated by weighting 
 events that are misclassified by the decision tree. The weight
 applied is w = (1-err)/err or more general:
            w = ((1-err)/err)^beta
 where err is the fracthin of misclassified events in the tree ( <0.5 assuming
 demanding the that previous selection was better than random guessing)
 and "beta" beeing a free parameter (standard: beta = 1) that modifies the
 boosting.
Double_t Bagging( vector<TMVA::Event*> eventSample, Int_t iTree )
 call it Bootstrapping, re-sampling or whatever you like, in the end it is nothing
 else but applying "random Weights" to each event.
void WriteWeightsToStream( ostream& o)
 and save the Weights
void ReadWeightsFromStream( istream& istr )
 read variable names and min/max
 NOTE: the latter values are mandatory for the normalisation 
 in the reader application !!!
Double_t GetMvaValue()
 return the MVA value (range [-1;1]) that classifies the
 event.according to the majority vote from the total number of
 decision trees
 In the literature I found that people actually use the 
 weighted majority vote (using the boost weights) .. However I
 did not see any improvement in doing so :(  
 --> this is currently switched off
void WriteMonitoringHistosToFile( void )
 here we could write some histograms created during the processing
 to the output file.
vector< Double_t > GetVariableImportance()
 return the relative variable importance, normalized to all
 variables together having the importance 1. The importance in
 evaluated as the total separation-gain that this variable had in
 the decision trees (weighted by the number of events)
Double_t GetVariableImportance( UInt_t ivar )
 returns the measure for the variable importance of variable "ivar"
 which is later used in GetVariableImportance() to calculat the
 relative variable importances
const TMVA::Ranking* CreateRanking()
 computes ranking of input variables
const std::vector<TMVA::DecisionTree*>& GetForest()
{ return fForest; }
const std::vector<TMVA::Event*>& GetTrainingEvents()
{ return fEventSample; }
const std::vector<double>& GetBoostWeights()
{ return fBoostWeights; }

Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss
Last update: root/tmva $Id: MethodBDT.cxx,v 1.11 2006/11/20 15:35:28 brun Exp $
Copyright (c) 2005: *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.