DecisionTreeTripleFeatureNode.cpp

#define GRT_DLL_EXPORTS
#include "DecisionTreeTripleFeatureNode.h"

GRT_BEGIN_NAMESPACE
    
//Register the DecisionTreeTripleFeatureNode module with the Node base class
RegisterNode< DecisionTreeTripleFeatureNode > DecisionTreeTripleFeatureNode::registerModule("DecisionTreeTripleFeatureNode");
    
DecisionTreeTripleFeatureNode::DecisionTreeTripleFeatureNode() : DecisionTreeNode("DecisionTreeTripleFeatureNode") {
    clear();
}

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

bool DecisionTreeTripleFeatureNode::predict_(VectorFloat &x) {

    if( (x[ featureIndexA ] - x[ featureIndexB ]) >= (x[ featureIndexC ] - x[ featureIndexB ]) ) return true;

    return false;
}

bool DecisionTreeTripleFeatureNode::clear(){
    
    //Call the base class clear function
    DecisionTreeNode::clear();
    
    featureIndexA = 0;
    featureIndexB = 0;
    featureIndexC = 0;
  
    return true;
}

bool DecisionTreeTripleFeatureNode::print() const{
    
    std::ostringstream stream;
    
    if( getModel( stream ) ){
        std::cout << stream.str();
        return true;
    }
    
    return false;
}
    
bool DecisionTreeTripleFeatureNode::getModel( std::ostream &stream ) const{

    std::string tab = "";
    for(UINT i=0; i<depth; i++) tab += "\t";
    
    stream << tab << "depth: " << depth;
    stream << " nodeSize: " << nodeSize;
    stream << " featureIndexA: " << featureIndexA;
    stream << " featureIndexB: " << featureIndexB;
    stream << " featureIndexC: " << featureIndexC;
    stream << " 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* DecisionTreeTripleFeatureNode::deepCopy() const{
    
    DecisionTreeTripleFeatureNode *node = new DecisionTreeTripleFeatureNode;
    
    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->featureIndexA = featureIndexA;
    node->featureIndexB = featureIndexB;
    node->featureIndexC = featureIndexC;
    node->classProbabilities = classProbabilities;
    
    //Recursively deep copy the left child
    if( leftChild ){
        node->leftChild = leftChild->deepCopy();
        node->leftChild->setParent( node );
    }
    
    //Recursively deep copy the right child
    if( rightChild ){
        node->rightChild = rightChild->deepCopy();
        node->rightChild->setParent( node );
    }
    
    return dynamic_cast< Node* >( node );
}

UINT DecisionTreeTripleFeatureNode::getFeatureIndexA() const{
    return featureIndexA;
}

UINT DecisionTreeTripleFeatureNode::getFeatureIndexB() const{
    return featureIndexB;
}

UINT DecisionTreeTripleFeatureNode::getFeatureIndexC() const{
    return featureIndexC;
}

bool DecisionTreeTripleFeatureNode::set(const UINT nodeSize,const UINT featureIndexA,const UINT featureIndexB,const UINT featureIndexC,const VectorFloat &classProbabilities){
    this->nodeSize = nodeSize;
    this->featureIndexA = featureIndexA;
    this->featureIndexB = featureIndexB;
    this->featureIndexC = featureIndexC;
    this->classProbabilities = classProbabilities;
    return true;
}

bool DecisionTreeTripleFeatureNode::computeBestSplitBestIterativeSplit( const UINT &numSplittingSteps, const ClassificationData &trainingData, const Vector< UINT > &features, const Vector< UINT > &classLabels, UINT &featureIndex, Float &minError ){
    return computeSplit( numSplittingSteps, trainingData, features, classLabels, featureIndex, minError);
}

bool DecisionTreeTripleFeatureNode::computeBestSplitBestRandomSplit( const UINT &numSplittingSteps, const ClassificationData &trainingData, const Vector< UINT > &features, const Vector< UINT > &classLabels, UINT &featureIndex, Float &minError ){
    return computeSplit( numSplittingSteps, trainingData, features, classLabels, featureIndex, minError);
}

bool DecisionTreeTripleFeatureNode::computeSplit( const UINT &numSplittingSteps, const ClassificationData &trainingData, const Vector< UINT > &features, const Vector< UINT > &classLabels, UINT &featureIndex, Float &minError ){

    const UINT M = trainingData.getNumSamples();
    const UINT N = features.getSize();
    const UINT K = classLabels.getSize();
    
    if( N == 0 ) return false;
    
    minError = grt_numeric_limits< Float >::max();
    Random random;
    UINT bestFeatureIndexA = 0;
    UINT bestFeatureIndexB = 0;
    UINT bestFeatureIndexC = 0;
    Float error = 0;
    Float giniIndexL = 0;
    Float giniIndexR = 0;
    Float weightL = 0;
    Float weightR = 0;
    Vector< UINT > groupIndex(M);
    VectorFloat groupCounter(2,0);
    Vector< MinMax > ranges = trainingData.getRanges();
    MatrixFloat classProbabilities(K,2);
    MatrixFloat data(M,1); //This will store our temporary data for each dimension
    
    //Randomly select which features we want to use
    UINT numRandomFeatures = numSplittingSteps > N ? N : numSplittingSteps;
    Vector< UINT > randomFeatures = random.getRandomSubset( 0, N, numRandomFeatures );

    //Loop over each random feature and try and find the best split point
    for(UINT n=0; n<numRandomFeatures; n++){
        
        //Randomly select 3 features to use
        featureIndexB = features[ randomFeatures[n] ]; //B is the central feature
        featureIndexA = features[ randomFeatures[ random.getRandomNumberInt(0,numRandomFeatures) ] ];
        featureIndexC = features[ randomFeatures[ random.getRandomNumberInt(0,numRandomFeatures) ] ];
        
        //Iterate over each sample and work out if it should be in the lhs (0) or rhs (1) group based on the current threshold
        groupCounter[0] = groupCounter[1] = 0;
        classProbabilities.setAllValues(0);
        for(UINT i=0; i<M; i++){
            groupIndex[i] = predict( trainingData[i].getSample() ) ? 1 : 0;
            groupCounter[ groupIndex[i] ]++;
            classProbabilities[ getClassLabelIndexValue(trainingData[i].getClassLabel(),classLabels) ][ groupIndex[i] ]++;
        }
     
        //Compute the class probabilities for the lhs group and rhs group
        for(UINT k=0; k<K; k++){
            classProbabilities[k][0] = groupCounter[0]>0 ? classProbabilities[k][0]/groupCounter[0] : 0;
            classProbabilities[k][1] = groupCounter[1]>0 ? classProbabilities[k][1]/groupCounter[1] : 0;
        }
     
        //Compute the Gini index for the lhs and rhs groups
        giniIndexL = giniIndexR = 0;
        for(UINT k=0; k<K; k++){
            giniIndexL += classProbabilities[k][0] * (1.0-classProbabilities[k][0]);
            giniIndexR += classProbabilities[k][1] * (1.0-classProbabilities[k][1]);
        }
        weightL = groupCounter[0]/M;
        weightR = groupCounter[1]/M;
        error = (giniIndexL*weightL) + (giniIndexR*weightR);
     
        //Store the best threshold and feature index
        if( error < minError ){
            minError = error;
            bestFeatureIndexA = featureIndexA;
            bestFeatureIndexB = featureIndexB;
            bestFeatureIndexC = featureIndexC;
        }
     }

     trainingLog << "Best features indexs: [" << bestFeatureIndexA << "," << bestFeatureIndexB << "," << bestFeatureIndexC << "] Min Error: " << minError << std::endl;
     
     //Set the best feature index that will be returned to the DecisionTree that called this function
     featureIndex = bestFeatureIndexB;
     
     //Store the node size, feature indexs and class probabilities for this node
     set(M,bestFeatureIndexA,bestFeatureIndexB,bestFeatureIndexC,trainingData.getClassProbabilities(classLabels));

     return true;
}

bool DecisionTreeTripleFeatureNode::saveParametersToFile( std::fstream &file ) const{
    
    if( !file.is_open() )
    {
        errorLog << "saveParametersToFile(fstream &file) - File is not open!" << std::endl;
        return false;
    }
    
    //Save the DecisionTreeNode parameters
    if( !DecisionTreeNode::saveParametersToFile( file ) ){
        errorLog << "saveParametersToFile(fstream &file) - Failed to save DecisionTreeNode parameters to file!" << std::endl;
        return false;
    }
    
    //Save the custom DecisionTreeThresholdNode parameters
    file << "FeatureIndexA: " << featureIndexA << std::endl;
    file << "FeatureIndexB: " << featureIndexB << std::endl;
    file << "FeatureIndexC: " << featureIndexC << std::endl;
    
    return true;
}

bool DecisionTreeTripleFeatureNode::loadParametersFromFile( std::fstream &file ){
    
    if(!file.is_open())
    {
        errorLog << "loadParametersFromFile(fstream &file) - File is not open!" << std::endl;
        return false;
    }
    
    //Load the DecisionTreeNode parameters
    if( !DecisionTreeNode::loadParametersFromFile( file ) ){
        errorLog << "loadParametersFromFile(fstream &file) - Failed to load DecisionTreeNode parameters from file!" << std::endl;
        return false;
    }
    
    std::string word;
    //Load the custom DecisionTreeThresholdNode Parameters
    file >> word;
    if( word != "FeatureIndexA:" ){
        errorLog << "loadParametersFromFile(fstream &file) - Failed to find FeatureIndexA header!" << std::endl;
        return false;
    }
    file >> featureIndexA;
    
    file >> word;
    if( word != "FeatureIndexB:" ){
        errorLog << "loadParametersFromFile(fstream &file) - Failed to find FeatureIndexB header!" << std::endl;
        return false;
    }
    file >> featureIndexB;

    file >> word;
    if( word != "FeatureIndexC:" ){
        errorLog << "loadParametersFromFile(fstream &file) - Failed to find FeatureIndexC header!" << std::endl;
        return false;
    }
    file >> featureIndexC;
 
    return true;
}

GRT_END_NAMESPACE