DecisionTreeNode.cpp

#include "DecisionTreeNode.h"

using namespace GRT;
 
//Register the DecisionTreeNode with the Node base class
RegisterNode< DecisionTreeNode > DecisionTreeNode::registerModule("DecisionTreeNode");
 
DecisionTreeNode::DecisionTreeNode(){
 nodeType = "DecisionTreeNode";
 parent = NULL;
 leftChild = NULL;
 rightChild = NULL;
 clear();
}

DecisionTreeNode::~DecisionTreeNode(){
 clear();
}

bool DecisionTreeNode::predict(const VectorFloat &x,VectorFloat &classLikelihoods){
 
 predictedNodeID = 0;
 
 if( isLeafNode ){
 classLikelihoods = classProbabilities;
 predictedNodeID = nodeID;
 return true;
 }
 
 if( leftChild == NULL && rightChild == NULL )
 return false;
 
 if( predict( x ) ){
 if( rightChild ){
 if( rightChild->predict( x, classLikelihoods ) ){
 predictedNodeID = rightChild->getPredictedNodeID();
 return true;
 }
 warningLog << "predict(const VectorFloat &x,VectorFloat &classLikelihoods) - Right child failed prediction!" << std::endl;
 return false;
 }
 }else{
 if( leftChild ){
 if( leftChild->predict( x, classLikelihoods ) ){
 predictedNodeID = leftChild->getPredictedNodeID();
 return true;
 }
 warningLog << "predict(const VectorFloat &x,VectorFloat &classLikelihoods) - Left child failed prediction!" << std::endl;
 return false;
 }
 }
 
 return false;
}

bool DecisionTreeNode::computeBestSpilt( const UINT &trainingMode, const UINT &numSplittingSteps,const ClassificationData &trainingData, const Vector< UINT > &features, const Vector< UINT > &classLabels, UINT &featureIndex, Float &minError ){
 
 switch( trainingMode ){
 case Tree::BEST_ITERATIVE_SPILT:
 return computeBestSpiltBestIterativeSpilt( numSplittingSteps, trainingData, features, classLabels, featureIndex, minError );
 break;
 case Tree::BEST_RANDOM_SPLIT:
 return computeBestSpiltBestRandomSpilt( numSplittingSteps, trainingData, features, classLabels, featureIndex, minError );
 break;
 default:
 errorLog << "computeBestSpilt(...) - Uknown trainingMode!" << std::endl;
 return false;
 break;
 }
 
 return false;
}

bool DecisionTreeNode::clear(){
 
 //Call the base class clear function
 Node::clear();
 
 nodeSize = 0;
 classProbabilities.clear();
 
 return true;
}
 
bool DecisionTreeNode::getModel( std::ostream &stream ) const{
 
 std::string tab = "";
 for(UINT i=0; i<depth; i++) tab += "\t";
 
 stream << tab << "depth: " << depth << " nodeSize: " << nodeSize << " isLeafNode: " << isLeafNode << std::endl;
 stream << tab << "ClassProbabilities: ";
 for(UINT i=0; i<classProbabilities.size(); i++){
 stream << classProbabilities[i] << "\t";
 }
 stream << std::endl;
 
 if( leftChild != NULL ){
 stream << tab << "LeftChild: " << std::endl;
 leftChild->getModel( stream );
 }
 
 if( rightChild != NULL ){
 stream << tab << "RightChild: " << std::endl;
 rightChild->getModel( stream );
 }
 
 return true;
}

Node* DecisionTreeNode::deepCopyNode() const{
 
 DecisionTreeNode *node = dynamic_cast< DecisionTreeNode* >( DecisionTreeNode::createInstanceFromString( nodeType ) );
 
 if( node == NULL ){
 return NULL;
 }
 
 //Copy this node into the node
 node->depth = depth;
 node->isLeafNode = isLeafNode;
 node->nodeID = nodeID;
 node->predictedNodeID = predictedNodeID;
 node->nodeSize = nodeSize;
 node->classProbabilities = classProbabilities;
 
 //Recursively deep copy the left child
 if( leftChild ){
 node->leftChild = leftChild->deepCopyNode();
 node->leftChild->setParent( node );
 }
 
 //Recursively deep copy the right child
 if( rightChild ){
 node->rightChild = rightChild->deepCopyNode();
 node->rightChild->setParent( node );
 }
 
 return node;
}

DecisionTreeNode* DecisionTreeNode::deepCopy() const{
 return dynamic_cast< DecisionTreeNode* >( deepCopyNode() );
}

UINT DecisionTreeNode::getNodeSize() const{
 return nodeSize;
}

UINT DecisionTreeNode::getNumClasses() const{
 return (UINT)classProbabilities.size();
}

VectorFloat DecisionTreeNode::getClassProbabilities() const{
 return classProbabilities;
}

bool DecisionTreeNode::setLeafNode( const UINT nodeSize, const VectorFloat &classProbabilities ){
 this->nodeSize = nodeSize;
 this->classProbabilities = classProbabilities;
 this->isLeafNode = true;
 return true;
}

bool DecisionTreeNode::setNodeSize(const UINT nodeSize){
 this->nodeSize = nodeSize;
 return true;
}

bool DecisionTreeNode::setClassProbabilities(const VectorFloat &classProbabilities){
 this->classProbabilities = classProbabilities;
 return true;
}
 
UINT DecisionTreeNode::getClassLabelIndexValue(UINT classLabel,const Vector< UINT > &classLabels){
 const UINT N = classLabels.getSize();
 for(UINT i=0; i<N; i++){
 if( classLabel == classLabels[i] )
 return i;
 }
 return 0;
}