Node for the Decision Tree
The node specifies ONE variable out of the given set of selection variable
that is used to split the sample which "arrives" at the node, into a left
(background-enhanced) and a right (signal-enhanced) sample.
virtual void | ReadAttributes(void* node) |
virtual void | ReadContent(stringstream& s) |
virtual Bool_t | ReadDataRecord(istream& is) |
Double_t | fAlpha | critical alpha for this node |
Double_t | fCC | debug variable for cost complexity pruing .. temporary bla |
Bool_t | fCutType | true: if event variable > cutValue ==> signal , false otherwise |
Float_t | fCutValue | cut value appplied on this node to discriminate bkg against sig |
Double_t | fG | minimum alpha in subtree rooted at this node |
Bool_t | fIsTerminalNode | ! flag to set node as terminal (i.e., without deleting its descendants) |
Double_t | fNB | sum of weights of background events from the pruning sample in this node |
Float_t | fNBkgEvents | sum of weights of backgr event in the node |
Float_t | fNBkgEvents_unweighted | sum of backgr event in the node |
Float_t | fNEvents | number of events in that entered the node (during training) |
Float_t | fNEvents_unweighted | number of events in that entered the node (during training) |
Double_t | fNS | ditto for the signal events |
Float_t | fNSigEvents | sum of weights of signal event in the node |
Float_t | fNSigEvents_unweighted | sum of signal event in the node |
Int_t | fNTerminal | number of terminal nodes in subtree rooted at this node |
Double_t | fNodeR | node resubstitution estimate, R(t) |
Int_t | fNodeType | Type of node: -1 == Bkg-leaf, 1 == Signal-leaf, 0 = internal |
Float_t | fRMS | response RMS of the regression node |
Float_t | fResponse | response value in case of regression |
vector<Float_t> | fSampleMax | the maxima for each ivar of the sample on the node during training |
vector<Float_t> | fSampleMin | the minima for each ivar of the sample on the node during training |
Short_t | fSelector | index of variable used in node selection (decision tree) |
Float_t | fSeparationGain | measure of "purity", separation, or information gained BY this nodes selection |
Float_t | fSeparationIndex | measure of "purity" (separation between S and B) AT this node |
ULong_t | fSequence | bit coded left right sequence to reach the node |
Double_t | fSubTreeR | R(T) = Sum(R(t) : t in ~T) |
Float_t | fSumTarget | sum of weight*target used for the calculatio of the variance (regression) |
Float_t | fSumTarget2 | sum of weight*target^2 used for the calculatio of the variance (regression) |
static TMVA::MsgLogger* | fgLogger | static because there is a huge number of nodes... |
copy constructor of a node. It will result in an explicit copy of the node and recursively all it's daughters
test event if it decends the tree at this node to the right
test event if it decends the tree at this node to the left
return the S/(S+B) (purity) for the node REM: even if nodes with purity 0.01 are very PURE background nodes, they still get a small value of the purity.
recursively print the node and its daughters (--> print the 'tree')
clear the nodes (their S/N, Nevents etc), just keep the structure of the tree
temporary stored node values (number of events, etc.) that originate not from the training but from the validation data (used in pruning)
return the minimum of variable ivar from the training sample that pass/end up in this node
return the maximum of variable ivar from the training sample that pass/end up in this node
set the minimum of variable ivar from the training sample that pass/end up in this node
set the maximum of variable ivar from the training sample that pass/end up in this node
adding attributes to tree node (well, was used in BinarySearchTree, and somehow I guess someone programmed it such that we need this in this tree too, although we don't..)
reading attributes from tree node (well, was used in BinarySearchTree, and somehow I guess someone programmed it such that we need this in this tree too, although we don't..)
set index of variable used for discrimination at this node
{ fSelector = i; }
set node type: 1 signal node, -1 bkg leave, 0 intermediate Node
{ fNodeType = t;}
set the number of events that entered the node (during training)
{ fNEvents =nev ; }
set the sum of the unweighted signal events in the node
{ fNSigEvents_unweighted = s; }
set the sum of the unweighted backgr events in the node
{ fNBkgEvents_unweighted = b; }
set the number of unweighted events that entered the node (during training)
{ fNEvents_unweighted =nev ; }
increment the sum of the signal weights in the node
{ fNSigEvents += s; }
increment the sum of the backgr weights in the node
{ fNBkgEvents += b; }
increment the number of events that entered the node (during training)
{ fNEvents +=nev ; }
increment the sum of the signal weights in the node
{ fNSigEvents_unweighted += 1; }
increment the sum of the backgr weights in the node
{ fNBkgEvents_unweighted += 1; }
increment the number of events that entered the node (during training)
{ fNEvents_unweighted +=1 ; }
return the sum of the signal weights in the node
{ return fNSigEvents; }
return the sum of the backgr weights in the node
{ return fNBkgEvents; }
return the number of events that entered the node (during training)
{ return fNEvents; }
return the sum of unweighted signal weights in the node
{ return fNSigEvents_unweighted; }
return the sum of unweighted backgr weights in the node
{ return fNBkgEvents_unweighted; }
return the number of unweighted events that entered the node (during training)
{ return fNEvents_unweighted; }
set the choosen index, measure of "purity" (separation between S and B) AT this node
{ fSeparationIndex =sep ; }
set the separation, or information gained BY this nodes selection
{ fSeparationGain =sep ; }
get pointers to children, mother in the tree
{ return dynamic_cast<DecisionTreeNode*>(GetLeft()); }
the node resubstitution estimate, R(t), for Cost Complexity pruning
{ fNodeR = r; }
the resubstitution estimate, R(T_t), of the tree rooted at this node
{ fSubTreeR = r; }
R(t) - R(T_t) the critical point alpha = ------------- |~T_t| - 1
{ fAlpha = alpha; }
number of background/signal events from the pruning validation sample
{ fNB = b; }