class TMVA::DecisionTreeNode: public TMVA::Node
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.
Function Members (Methods)
public:
private:
| virtual void | ReadAttributes(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_CODE) |
| virtual void | ReadContent(stringstream& s) |
| virtual Bool_t | ReadDataRecord(istream& is, UInt_t tmva_Version_Code = TMVA_VERSION_CODE) |
Data Members
protected:
| 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 |
| UInt_t | TMVA::Node::fDepth | depth of the node within the tree (seen from root node) |
| vector<Double_t> | fFisherCoeff | the fisher coeff (offset at the last element) |
| Bool_t | fIsTerminalNode | ! flag to set node as terminal (i.e., without deleting its descendants) |
| TMVA::Node* | TMVA::Node::fLeft | pointers to the two "daughter" nodes |
| Int_t | fNodeType | Type of node: -1 == Bkg-leaf, 1 == Signal-leaf, 0 = internal |
| TMVA::Node* | TMVA::Node::fParent | the previous (parent) node |
| TMVA::BinaryTree* | TMVA::Node::fParentTree | pointer to the parent tree to which the Node belongs |
| char | TMVA::Node::fPos | position, i.e. it is a left (l) or right (r) daughter |
| Float_t | fPurity | the node purity |
| Float_t | fRMS | response RMS of the regression node |
| Float_t | fResponse | response value in case of regression |
| TMVA::Node* | TMVA::Node::fRight | pointers to the two "daughter" nodes |
| Short_t | fSelector | index of variable used in node selection (decision tree) |
| TMVA::DTNodeTrainingInfo* | fTrainInfo | |
| static TMVA::MsgLogger* | fgLogger | static because there is a huge number of nodes... |
Class Charts
Function documentation
DecisionTreeNode(const TMVA::DecisionTreeNode& n, TMVA::DecisionTreeNode* parent = NULL)
copy constructor of a node. It will result in an explicit copy of the node and recursively all it's daughters
Bool_t GoesRight(const TMVA::Event& ) const
test event if it decends the tree at this node to the right
Bool_t GoesLeft(const TMVA::Event& ) const
test event if it decends the tree at this node to the left
void SetPurity( void )
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.
void PrintRec(ostream& os) const
recursively print the node and its daughters (--> print the 'tree')
Bool_t ReadDataRecord(istream& is, UInt_t tmva_Version_Code = TMVA_VERSION_CODE)
Read the data block
void ClearNodeAndAllDaughters()
clear the nodes (their S/N, Nevents etc), just keep the structure of the tree
void ResetValidationData()
temporary stored node values (number of events, etc.) that originate not from the training but from the validation data (used in pruning)
Float_t GetSampleMin(UInt_t ivar) const
return the minimum of variable ivar from the training sample that pass/end up in this node
Float_t GetSampleMax(UInt_t ivar) const
return the maximum of variable ivar from the training sample that pass/end up in this node
void SetSampleMin(UInt_t ivar, Float_t xmin)
set the minimum of variable ivar from the training sample that pass/end up in this node
void SetSampleMax(UInt_t ivar, Float_t xmax)
set the maximum of variable ivar from the training sample that pass/end up in this node
void ReadAttributes(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_CODE)
void AddContentToNode(stringstream& s) const
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..)
void ReadContent(stringstream& s)
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..)
void SetSelector(Short_t i)
set index of variable used for discrimination at this node
{ fSelector = i; }Short_t GetSelector() const
return index of variable used for discrimination at this node
{ return fSelector; }void SetNodeType(Int_t t)
set node type: 1 signal node, -1 bkg leave, 0 intermediate Node
{ fNodeType = t;}Int_t GetNodeType( void )
return node type: 1 signal node, -1 bkg leave, 0 intermediate Node
{ return fNodeType; }void SetNSigEvents(Float_t s)
set the sum of the signal weights in the node
{ fTrainInfo->fNSigEvents = s; }void SetNBkgEvents(Float_t b)
set the sum of the backgr weights in the node
{ fTrainInfo->fNBkgEvents = b; }void SetNEvents(Float_t nev)
set the number of events that entered the node (during training)
{ fTrainInfo->fNEvents =nev ; }void SetNSigEvents_unweighted(Float_t s)
set the sum of the unweighted signal events in the node
{ fTrainInfo->fNSigEvents_unweighted = s; }void SetNBkgEvents_unweighted(Float_t b)
set the sum of the unweighted backgr events in the node
{ fTrainInfo->fNBkgEvents_unweighted = b; }void SetNEvents_unweighted(Float_t nev)
set the number of unweighted events that entered the node (during training)
{ fTrainInfo->fNEvents_unweighted =nev ; }void IncrementNSigEvents(Float_t s)
increment the sum of the signal weights in the node
{ fTrainInfo->fNSigEvents += s; }void IncrementNBkgEvents(Float_t b)
increment the sum of the backgr weights in the node
{ fTrainInfo->fNBkgEvents += b; }void IncrementNEvents(Float_t nev)
increment the number of events that entered the node (during training)
{ fTrainInfo->fNEvents +=nev ; }void IncrementNSigEvents_unweighted()
increment the sum of the signal weights in the node
{ fTrainInfo->fNSigEvents_unweighted += 1; }void IncrementNBkgEvents_unweighted()
increment the sum of the backgr weights in the node
{ fTrainInfo->fNBkgEvents_unweighted += 1; }void IncrementNEvents_unweighted()
increment the number of events that entered the node (during training)
{ fTrainInfo->fNEvents_unweighted +=1 ; }Float_t GetNSigEvents( void )
return the sum of the signal weights in the node
{ return fTrainInfo->fNSigEvents; }Float_t GetNBkgEvents( void )
return the sum of the backgr weights in the node
{ return fTrainInfo->fNBkgEvents; }Float_t GetNEvents( void )
return the number of events that entered the node (during training)
{ return fTrainInfo->fNEvents; }Float_t GetNSigEvents_unweighted( void )
return the sum of unweighted signal weights in the node
{ return fTrainInfo->fNSigEvents_unweighted; }Float_t GetNBkgEvents_unweighted( void )
return the sum of unweighted backgr weights in the node
{ return fTrainInfo->fNBkgEvents_unweighted; }Float_t GetNEvents_unweighted( void )
return the number of unweighted events that entered the node (during training)
{ return fTrainInfo->fNEvents_unweighted; }void SetSeparationIndex(Float_t sep)
set the choosen index, measure of "purity" (separation between S and B) AT this node
{ fTrainInfo->fSeparationIndex =sep ; }Float_t GetSeparationIndex( void )
return the separation index AT this node
{ return fTrainInfo->fSeparationIndex; }void SetSeparationGain(Float_t sep)
set the separation, or information gained BY this nodes selection
{ fTrainInfo->fSeparationGain =sep ; }Float_t GetSeparationGain( void )
return the gain in separation obtained by this nodes selection
{ return fTrainInfo->fSeparationGain; }DecisionTreeNode* GetLeft() const
get pointers to children, mother in the tree return pointer to the left/right daughter or parent node
{ return dynamic_cast<DecisionTreeNode*>(fLeft); }void SetLeft(TMVA::Node* l)
set pointer to the left/right daughter and parent node
{ fLeft = dynamic_cast<DecisionTreeNode*>(l);}void SetNodeR(Double_t r)
the node resubstitution estimate, R(t), for Cost Complexity pruning
{ fTrainInfo->fNodeR = r; }void SetSubTreeR(Double_t r)
the resubstitution estimate, R(T_t), of the tree rooted at this node
{ fTrainInfo->fSubTreeR = r; }void SetAlpha(Double_t alpha)
R(t) - R(T_t)
the critical point alpha = -------------
|~T_t| - 1
{ fTrainInfo->fAlpha = alpha; }void SetAlphaMinSubtree(Double_t g)
the minimum alpha in the tree rooted at this node
{ fTrainInfo->fG = g; }void SetNTerminal(Int_t n)
number of terminal nodes in the subtree rooted here
{ fTrainInfo->fNTerminal = n; }void SetNBValidation(Double_t b)
number of background/signal events from the pruning validation sample
{ fTrainInfo->fNB = b; }