Logo ROOT  
Reference Guide
DecisionTree.h
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Jan Therhaag, Eckhard von Toerne
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6  * Package: TMVA *
7  * Class : DecisionTree *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * Implementation of a Decision Tree *
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  * Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany *
18  * Eckhard v. Toerne <evt@uni-bonn.de> - 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://mva.sourceforge.net/license.txt) *
29  * *
30  **********************************************************************************/
31 
32 #ifndef ROOT_TMVA_DecisionTree
33 #define ROOT_TMVA_DecisionTree
34 
35 //////////////////////////////////////////////////////////////////////////
36 // //
37 // DecisionTree //
38 // //
39 // Implementation of a Decision Tree //
40 // //
41 //////////////////////////////////////////////////////////////////////////
42 
43 #include "TH2.h"
44 #include <vector>
45 
46 #include "TMVA/Types.h"
47 #include "TMVA/DecisionTreeNode.h"
48 #include "TMVA/BinaryTree.h"
49 #include "TMVA/BinarySearchTree.h"
50 #include "TMVA/SeparationBase.h"
52 #include "TMVA/DataSetInfo.h"
53 
54 #ifdef R__USE_IMT
55 #include <ROOT/TThreadExecutor.hxx>
56 #include "TSystem.h"
57 #endif
58 
59 class TRandom3;
60 
61 namespace TMVA {
62 
63  class Event;
64 
65  class DecisionTree : public BinaryTree {
66 
67  private:
68 
69  static const Int_t fgRandomSeed; // set nonzero for debugging and zero for random seeds
70 
71  public:
72 
73  typedef std::vector<TMVA::Event*> EventList;
74  typedef std::vector<const TMVA::Event*> EventConstList;
75 
76  // the constructur needed for the "reading" of the decision tree from weight files
77  DecisionTree( void );
78 
79  // the constructur needed for constructing the decision tree via training with events
80  DecisionTree( SeparationBase *sepType, Float_t minSize,
81  Int_t nCuts, DataSetInfo* = NULL,
82  UInt_t cls =0,
83  Bool_t randomisedTree=kFALSE, Int_t useNvars=0, Bool_t usePoissonNvars=kFALSE,
84  UInt_t nMaxDepth=9999999,
85  Int_t iSeed=fgRandomSeed, Float_t purityLimit=0.5,
86  Int_t treeID = 0);
87 
88  // copy constructor
89  DecisionTree (const DecisionTree &d);
90 
91  virtual ~DecisionTree( void );
92 
93  // Retrieves the address of the root node
94  virtual DecisionTreeNode* GetRoot() const { return static_cast<TMVA::DecisionTreeNode*>(fRoot); }
95  virtual DecisionTreeNode * CreateNode(UInt_t) const { return new DecisionTreeNode(); }
96  virtual BinaryTree* CreateTree() const { return new DecisionTree(); }
97  static DecisionTree* CreateFromXML(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_CODE);
98  virtual const char* ClassName() const { return "DecisionTree"; }
99 
100  // building of a tree by recursivly splitting the nodes
101 
102  // UInt_t BuildTree( const EventList & eventSample,
103  // DecisionTreeNode *node = NULL);
104  UInt_t BuildTree( const EventConstList & eventSample,
105  DecisionTreeNode *node = NULL);
106  // determine the way how a node is split (which variable, which cut value)
107 
108  Double_t TrainNode( const EventConstList & eventSample, DecisionTreeNode *node ) { return TrainNodeFast( eventSample, node ); }
109  Double_t TrainNodeFast( const EventConstList & eventSample, DecisionTreeNode *node );
110  Double_t TrainNodeFull( const EventConstList & eventSample, DecisionTreeNode *node );
111  void GetRandomisedVariables(Bool_t *useVariable, UInt_t *variableMap, UInt_t & nVars);
112  std::vector<Double_t> GetFisherCoefficients(const EventConstList &eventSample, UInt_t nFisherVars, UInt_t *mapVarInFisher);
113 
114  // fill at tree with a given structure already (just see how many signa/bkgr
115  // events end up in each node
116 
117  void FillTree( const EventList & eventSample);
118 
119  // fill the existing the decision tree structure by filling event
120  // in from the top node and see where they happen to end up
121  void FillEvent( const TMVA::Event & event,
122  TMVA::DecisionTreeNode *node );
123 
124  // returns: 1 = Signal (right), -1 = Bkg (left)
125 
126  Double_t CheckEvent( const TMVA::Event * , Bool_t UseYesNoLeaf = kFALSE ) const;
128 
129  // return the individual relative variable importance
130  std::vector< Double_t > GetVariableImportance();
131 
133 
134  // clear the tree nodes (their S/N, Nevents etc), just keep the structure of the tree
135 
136  void ClearTree();
137 
138  // set pruning method
141 
142  // recursive pruning of the tree, validation sample required for automatic pruning
143  Double_t PruneTree( const EventConstList* validationSample = NULL );
144 
145  // manage the pruning strength parameter (iff < 0 -> automate the pruning process)
148 
149  // apply pruning validation sample to a decision tree
150  void ApplyValidationSample( const EventConstList* validationSample ) const;
151 
152  // return the misclassification rate of a pruned tree
153  Double_t TestPrunedTreeQuality( const DecisionTreeNode* dt = NULL, Int_t mode=0 ) const;
154 
155  // pass a single validation event throught a pruned decision tree
156  void CheckEventWithPrunedTree( const TMVA::Event* ) const;
157 
158  // calculate the normalization factor for a pruning validation sample
159  Double_t GetSumWeights( const EventConstList* validationSample ) const;
160 
163 
164  void DescendTree( Node *n = NULL );
165  void SetParentTreeInNodes( Node *n = NULL );
166 
167  // retrieve node from the tree. Its position (up to a maximal tree depth of 64)
168  // is coded as a sequence of left-right moves starting from the root, coded as
169  // 0-1 bit patterns stored in the "long-integer" together with the depth
170  Node* GetNode( ULong_t sequence, UInt_t depth );
171 
172  UInt_t CleanTree(DecisionTreeNode *node=NULL);
173 
174  void PruneNode(TMVA::DecisionTreeNode *node);
175 
176  // prune a node from the tree without deleting its descendants; allows one to
177  // effectively prune a tree many times without making deep copies
179 
181 
182 
184 
185  void SetTreeID(Int_t treeID){fTreeID = treeID;};
186  Int_t GetTreeID(){return fTreeID;};
187 
194  inline void SetNVars(Int_t n){fNvars = n;}
195 
196  private:
197  // utility functions
198 
199  // calculate the Purity out of the number of sig and bkg events collected
200  // from individual samples.
201 
202  // calculates the purity S/(S+B) of a given event sample
203  Double_t SamplePurity(EventList eventSample);
204 
205  UInt_t fNvars; // number of variables used to separate S and B
206  Int_t fNCuts; // number of grid point in variable cut scans
207  Bool_t fUseFisherCuts; // use multivariate splits using the Fisher criterium
208  Double_t fMinLinCorrForFisher; // the minimum linear correlation between two variables demanded for use in fisher criterium in node splitting
209  Bool_t fUseExclusiveVars; // individual variables already used in fisher criterium are not anymore analysed individually for node splitting
210 
211  SeparationBase *fSepType; // the separation crition
212  RegressionVariance *fRegType; // the separation crition used in Regression
213 
214  Double_t fMinSize; // min number of events in node
215  Double_t fMinNodeSize; // min fraction of training events in node
216  Double_t fMinSepGain; // min number of separation gain to perform node splitting
217 
218  Bool_t fUseSearchTree; // cut scan done with binary trees or simple event loop.
219  Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted
220 
221  EPruneMethod fPruneMethod; // method used for prunig
222  Int_t fNNodesBeforePruning; //remember this one (in case of pruning, it allows to monitor the before/after
223 
224  Double_t fNodePurityLimit;// purity limit to decide whether a node is signal
225 
226  Bool_t fRandomisedTree; // choose at each node splitting a random set of variables
227  Int_t fUseNvars; // the number of variables used in randomised trees;
228  Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number but as mean of a possion distr. in each split
229 
230  TRandom3 *fMyTrandom; // random number generator for randomised trees
231 
232  std::vector< Double_t > fVariableImportance; // the relative importance of the different variables
233 
234  UInt_t fMaxDepth; // max depth
235  UInt_t fSigClass; // class which is treated as signal when building the tree
236  static const Int_t fgDebugLevel = 0; // debug level determining some printout/control plots etc.
237  Int_t fTreeID; // just an ID number given to the tree.. makes debugging easier as tree knows who he is.
238 
239  Types::EAnalysisType fAnalysisType; // kClassification(=0=false) or kRegression(=1=true)
240 
242 
243  ClassDef(DecisionTree,0); // implementation of a Decision Tree
244  };
245 
246 } // namespace TMVA
247 
248 #endif
m
auto * m
Definition: textangle.C:8
TMVA::RegressionVariance
Definition: RegressionVariance.h:97
n
const Int_t n
Definition: legend1.C:16
TMVA::DecisionTree::SetNodePurityLimit
void SetNodePurityLimit(Double_t p)
Definition: DecisionTree.h:161
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
e
#define e(i)
Definition: RSha256.hxx:121
TMVA::DecisionTree::fAnalysisType
Types::EAnalysisType fAnalysisType
Definition: DecisionTree.h:239
TMVA::DecisionTree::CreateFromXML
static DecisionTree * CreateFromXML(void *node, UInt_t tmva_Version_Code=TMVA_VERSION_CODE)
re-create a new tree (decision tree or search tree) from XML
Definition: DecisionTree.cxx:281
TMVA::DecisionTree::EPruneMethod
EPruneMethod
Definition: DecisionTree.h:139
TMVA::DecisionTree::fMinLinCorrForFisher
Double_t fMinLinCorrForFisher
Definition: DecisionTree.h:208
TMVA::Types::kRegression
@ kRegression
Definition: Types.h:152
TMVA::DecisionTree::SetParentTreeInNodes
void SetParentTreeInNodes(Node *n=NULL)
descend a tree to find all its leaf nodes, fill max depth reached in the tree at the same time.
Definition: DecisionTree.cxx:248
TMVA::DecisionTree::SetAnalysisType
void SetAnalysisType(Types::EAnalysisType t)
Definition: DecisionTree.h:189
TMVA::DecisionTree::FillTree
void FillTree(const EventList &eventSample)
fill the existing the decision tree structure by filling event in from the top node and see where the...
Definition: DecisionTree.cxx:880
TMVA::DecisionTree::GetNNodesBeforePruning
Int_t GetNNodesBeforePruning()
Definition: DecisionTree.h:180
TMVA::DecisionTree::fPruneMethod
EPruneMethod fPruneMethod
Definition: DecisionTree.h:221
DataSetInfo.h
TMVA::DecisionTree::fUseFisherCuts
Bool_t fUseFisherCuts
Definition: DecisionTree.h:207
TMVA::DecisionTree::DecisionTree
DecisionTree(void)
default constructor using the GiniIndex as separation criterion, no restrictions on minium number of ...
Definition: DecisionTree.cxx:115
TMVA::DecisionTree::fgRandomSeed
static const Int_t fgRandomSeed
Definition: DecisionTree.h:69
TMVA::DecisionTree::SetPruneMethod
void SetPruneMethod(EPruneMethod m=kCostComplexityPruning)
Definition: DecisionTree.h:140
TMVA::DecisionTree::fSigClass
UInt_t fSigClass
Definition: DecisionTree.h:235
TMVA::DecisionTree::SetUseFisherCuts
void SetUseFisherCuts(Bool_t t=kTRUE)
Definition: DecisionTree.h:191
TMVA::DecisionTree::TrainNodeFull
Double_t TrainNodeFull(const EventConstList &eventSample, DecisionTreeNode *node)
train a node by finding the single optimal cut for a single variable that best separates signal and b...
Definition: DecisionTree.cxx:2536
TMVA::DecisionTree::ClassName
virtual const char * ClassName() const
Definition: DecisionTree.h:98
Float_t
float Float_t
Definition: RtypesCore.h:57
TMVA::DecisionTree::CheckEvent
Double_t CheckEvent(const TMVA::Event *, Bool_t UseYesNoLeaf=kFALSE) const
the event e is put into the decision tree (starting at the root node) and the output is NodeType (sig...
Definition: DecisionTree.cxx:2690
TMVA::DecisionTree::kExpectedErrorPruning
@ kExpectedErrorPruning
Definition: DecisionTree.h:139
TMVA::DecisionTreeNode
Definition: DecisionTreeNode.h:141
TMVA::DecisionTree::kNoPruning
@ kNoPruning
Definition: DecisionTree.h:139
TMVA::DecisionTree::TestPrunedTreeQuality
Double_t TestPrunedTreeQuality(const DecisionTreeNode *dt=NULL, Int_t mode=0) const
return the misclassification rate of a pruned tree a "pruned tree" may have set the variable "IsTermi...
Definition: DecisionTree.cxx:1043
Bool_t
bool Bool_t
Definition: RtypesCore.h:63
TMVA::BinaryTree::fRoot
Node * fRoot
Definition: BinaryTree.h:134
TMVA::DecisionTree::CountLeafNodes
UInt_t CountLeafNodes(TMVA::Node *n=NULL)
return the number of terminal nodes in the sub-tree below Node n
Definition: DecisionTree.cxx:1131
TMVA::DecisionTree::fMinSize
Double_t fMinSize
Definition: DecisionTree.h:214
TMVA::DecisionTree::fNNodesBeforePruning
Int_t fNNodesBeforePruning
Definition: DecisionTree.h:222
TMVA::Node
Definition: Node.h:80
TMVA::DecisionTree::fTreeID
Int_t fTreeID
Definition: DecisionTree.h:237
TMVA::DecisionTree::SetUseExclusiveVars
void SetUseExclusiveVars(Bool_t t=kTRUE)
Definition: DecisionTree.h:193
TMVA::DecisionTree::PruneNode
void PruneNode(TMVA::DecisionTreeNode *node)
prune away the subtree below the node
Definition: DecisionTree.cxx:1194
TMVA::DecisionTree
Definition: DecisionTree.h:65
bool
TMVA::DecisionTree::fUseExclusiveVars
Bool_t fUseExclusiveVars
Definition: DecisionTree.h:209
TMVA::DecisionTree::fUseNvars
Int_t fUseNvars
Definition: DecisionTree.h:227
TMVA::DecisionTree::GetNodePurityLimit
Double_t GetNodePurityLimit() const
Definition: DecisionTree.h:162
TMVA::DecisionTree::fMaxDepth
UInt_t fMaxDepth
Definition: DecisionTree.h:234
RegressionVariance.h
TMVA::DecisionTree::CleanTree
UInt_t CleanTree(DecisionTreeNode *node=NULL)
remove those last splits that result in two leaf nodes that are both of the type (i....
Definition: DecisionTree.cxx:937
TMVA::DecisionTree::~DecisionTree
virtual ~DecisionTree(void)
destructor
Definition: DecisionTree.cxx:236
TMVA::DecisionTree::GetRandomisedVariables
void GetRandomisedVariables(Bool_t *useVariable, UInt_t *variableMap, UInt_t &nVars)
Definition: DecisionTree.cxx:1247
TMVA::DecisionTree::fUsePoissonNvars
Bool_t fUsePoissonNvars
Definition: DecisionTree.h:228
TMVA::DecisionTree::GetFisherCoefficients
std::vector< Double_t > GetFisherCoefficients(const EventConstList &eventSample, UInt_t nFisherVars, UInt_t *mapVarInFisher)
calculate the fisher coefficients for the event sample and the variables used
Definition: DecisionTree.cxx:2342
TMVA::DecisionTree::GetRoot
virtual DecisionTreeNode * GetRoot() const
Definition: DecisionTree.h:94
TMVA::DecisionTree::CheckEventWithPrunedTree
void CheckEventWithPrunedTree(const TMVA::Event *) const
pass a single validation event through a pruned decision tree on the way down the tree,...
Definition: DecisionTree.cxx:1085
TMVA::DataSetInfo
Definition: DataSetInfo.h:62
SeparationBase.h
TMVA::DecisionTree::GetEventNode
TMVA::DecisionTreeNode * GetEventNode(const TMVA::Event &e) const
get the pointer to the leaf node where a particular event ends up in...
Definition: DecisionTree.cxx:2673
TMVA::DecisionTree::GetTreeID
Int_t GetTreeID()
Definition: DecisionTree.h:186
TSystem.h
BinarySearchTree.h
TRandom3
Definition: TRandom3.h:27
TMVA::Types::EAnalysisType
EAnalysisType
Definition: Types.h:150
TMVA::DecisionTree::SetMinLinCorrForFisher
void SetMinLinCorrForFisher(Double_t min)
Definition: DecisionTree.h:192
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TThreadExecutor.hxx
TMVA::BinaryTree
Definition: BinaryTree.h:86
TMVA::DecisionTree::fMinSepGain
Double_t fMinSepGain
Definition: DecisionTree.h:216
TMVA::DecisionTree::fgDebugLevel
static const Int_t fgDebugLevel
Definition: DecisionTree.h:236
TMVA::DecisionTree::TrainNodeFast
Double_t TrainNodeFast(const EventConstList &eventSample, DecisionTreeNode *node)
Decide how to split a node using one of the variables that gives the best separation of signal/backgr...
Definition: DecisionTree.cxx:1374
TMVA::DecisionTree::ApplyValidationSample
void ApplyValidationSample(const EventConstList *validationSample) const
run the validation sample through the (pruned) tree and fill in the nodes the variables NSValidation ...
Definition: DecisionTree.cxx:1029
TMVA::DecisionTree::GetPruneStrength
Double_t GetPruneStrength() const
Definition: DecisionTree.h:147
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:46
TMVA::DecisionTree::SetTreeID
void SetTreeID(Int_t treeID)
Definition: DecisionTree.h:185
TMVA::DecisionTree::SetPruneStrength
void SetPruneStrength(Double_t p)
Definition: DecisionTree.h:146
TMVA::DecisionTree::BuildTree
UInt_t BuildTree(const EventConstList &eventSample, DecisionTreeNode *node=NULL)
building the decision tree by recursively calling the splitting of one (root-) node into two daughter...
Definition: DecisionTree.cxx:377
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:55
TMVA::DecisionTree::DoRegression
Bool_t DoRegression() const
Definition: DecisionTree.h:188
Types.h
TMVA::DecisionTree::fVariableImportance
std::vector< Double_t > fVariableImportance
Definition: DecisionTree.h:232
TH2.h
TMVA::DecisionTree::fMinNodeSize
Double_t fMinNodeSize
Definition: DecisionTree.h:215
unsigned int
TMVA::SeparationBase
Definition: SeparationBase.h:121
BinaryTree.h
TMVA::DecisionTree::PruneTree
Double_t PruneTree(const EventConstList *validationSample=NULL)
prune (get rid of internal nodes) the Decision tree to avoid overtraining several different pruning m...
Definition: DecisionTree.cxx:964
Double_t
double Double_t
Definition: RtypesCore.h:59
DecisionTreeNode.h
TMVA::DecisionTree::EventList
std::vector< TMVA::Event * > EventList
Definition: DecisionTree.h:73
TMVA::DecisionTree::fDataSetInfo
DataSetInfo * fDataSetInfo
Definition: DecisionTree.h:241
TMVA_VERSION_CODE
#define TMVA_VERSION_CODE
Definition: Version.h:47
TMVA::DecisionTree::ClearTree
void ClearTree()
clear the tree nodes (their S/N, Nevents etc), just keep the structure of the tree
Definition: DecisionTree.cxx:923
TMVA::DecisionTree::kCostComplexityPruning
@ kCostComplexityPruning
Definition: DecisionTree.h:139
TMVA::DecisionTree::GetSumWeights
Double_t GetSumWeights(const EventConstList *validationSample) const
calculate the normalization factor for a pruning validation sample
Definition: DecisionTree.cxx:1118
TMVA::DecisionTree::CreateTree
virtual BinaryTree * CreateTree() const
Definition: DecisionTree.h:96
TMVA::Event
Definition: Event.h:51
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
TMVA::BinaryTree::GetNNodes
UInt_t GetNNodes() const
Definition: BinaryTree.h:110
TMVA::DecisionTree::GetVariableImportance
std::vector< Double_t > GetVariableImportance()
Return the relative variable importance, normalized to all variables together having the importance 1...
Definition: DecisionTree.cxx:2745
TMVA::DecisionTree::DescendTree
void DescendTree(Node *n=NULL)
descend a tree to find all its leaf nodes
Definition: DecisionTree.cxx:1160
d
#define d(i)
Definition: RSha256.hxx:120
TMVA::DecisionTree::GetNode
Node * GetNode(ULong_t sequence, UInt_t depth)
retrieve node from the tree.
Definition: DecisionTree.cxx:1231
TMVA::DecisionTree::fPruneStrength
Double_t fPruneStrength
Definition: DecisionTree.h:219
TMVA::DecisionTree::fSepType
SeparationBase * fSepType
Definition: DecisionTree.h:211
TMVA::DecisionTree::fNodePurityLimit
Double_t fNodePurityLimit
Definition: DecisionTree.h:224
TMVA::DecisionTree::PruneNodeInPlace
void PruneNodeInPlace(TMVA::DecisionTreeNode *node)
prune a node temporarily (without actually deleting its descendants which allows testing the pruned t...
Definition: DecisionTree.cxx:1217
TMVA::DecisionTree::CreateNode
virtual DecisionTreeNode * CreateNode(UInt_t) const
Definition: DecisionTree.h:95
TMVA::DecisionTree::fUseSearchTree
Bool_t fUseSearchTree
Definition: DecisionTree.h:218
TMVA::DecisionTree::SamplePurity
Double_t SamplePurity(EventList eventSample)
calculates the purity S/(S+B) of a given event sample
Definition: DecisionTree.cxx:2722
TMVA::DecisionTree::fRegType
RegressionVariance * fRegType
Definition: DecisionTree.h:212
TMVA::DecisionTree::FillEvent
void FillEvent(const TMVA::Event &event, TMVA::DecisionTreeNode *node)
fill the existing the decision tree structure by filling event in from the top node and see where the...
Definition: DecisionTree.cxx:891
TMVA::DecisionTree::TrainNode
Double_t TrainNode(const EventConstList &eventSample, DecisionTreeNode *node)
Definition: DecisionTree.h:108
TMVA::DecisionTree::EventConstList
std::vector< const TMVA::Event * > EventConstList
Definition: DecisionTree.h:74
TMVA::DecisionTree::GetAnalysisType
Types::EAnalysisType GetAnalysisType(void)
Definition: DecisionTree.h:190
TMVA::DecisionTree::fMyTrandom
TRandom3 * fMyTrandom
Definition: DecisionTree.h:230
TMVA::DecisionTree::fRandomisedTree
Bool_t fRandomisedTree
Definition: DecisionTree.h:226
TMVA::DecisionTree::fNvars
UInt_t fNvars
Definition: DecisionTree.h:205
TMVA
create variable transformations
Definition: GeneticMinimizer.h:22
int
TMVA::DecisionTree::SetNVars
void SetNVars(Int_t n)
Definition: DecisionTree.h:194
TMVA::DecisionTree::fNCuts
Int_t fNCuts
Definition: DecisionTree.h:206