NICE_VisLearning/classifier/fpclassifier/randomforest/DTBRandomOblique.h

/**
 * @file DTBRandomOblique.h
 * @brief random oblique decision tree
 * @author Sven Sickert
 * @date 10/15/2014

*/
#ifndef DTBRANDOMOBLIQUEINCLUDE
#define DTBRANDOMOBLIQUEINCLUDE

#include "core/vector/VectorT.h"
#include "core/vector/MatrixT.h"

#include "core/basics/Config.h"
#include "DecisionTreeBuilder.h"
#include "vislearning/cbaselib/CachedExample.h"


namespace OBJREC {

/** random oblique decision tree */
class DTBRandomOblique : public DecisionTreeBuilder
{
  protected:

    /////////////////////////
    /////////////////////////
    // PROTECTED VARIABLES //
    /////////////////////////
    /////////////////////////

    /** Amount of randomly chosen thresholds */
    int random_split_tests;

    /** Amount of randomly chosen features */
    int random_features;

    /** Maximum allowed depth of a tree */
    int max_depth;

    /* Minimum amount of features in a leaf node */
    int min_examples;

    /** Minimum entropy to continue with splitting */
    int minimum_entropy;

    /** Minimum information gain to continue with splitting */
    int minimum_information_gain;

    /** Whether to use shannon entropy or not */
    bool use_shannon_entropy;

    /** Whether to save indices in leaves or not */
    bool save_indices;

    /////////////////////////
    /////////////////////////
    //  PROTECTED METHODS  //
    /////////////////////////
    /////////////////////////

    /**
     * @brief recursive building method
     * @param fp feature pool
     * @param examples all examples of the training
     * @param examples_selection indeces of selected example subset
     * @param distribution class distribution in current node
     * @param entropy current entropy
     * @param maxClassNo maximum class number
     * @param depth current depth
     * @return Pointer to root/parent node
     */
    DecisionNode *buildRecursive ( const FeaturePool & fp,
           const Examples & examples,
           std::vector<int> & examples_selection,
           FullVector & distribution,
           double entropy,
           int maxClassNo,
           int depth );

    /**
     * @brief compute entropy for left and right child
     * @param values feature values
     * @param threshold threshold for split
     * @param stat_left statistics for left child
     * @param stat_right statistics for right child
     * @param entropy_left entropy for left child
     * @param entropy_right entropy for right child
     * @param count_left amount of features in left child
     * @param count_right amount of features in right child
     * @param maxClassNo maximum class number
     * @return whether another split is possible or not
     */
    bool entropyLeftRight ( const FeatureValuesUnsorted & values,
           double threshold,
           double* stat_left,
           double* stat_right,
           double & entropy_left,
           double & entropy_right,
           double & count_left,
           double & count_right,
           int maxClassNo );

  public:

    /** simple constructor */
    DTBRandomOblique ( const NICE::Config *conf,
                       std::string section = "DTBRandomOblique" );

    /** simple destructor */
    virtual ~DTBRandomOblique();

    /**
     * @brief initial building method
     * @param fp feature pool
     * @param examples all examples of the training
     * @param maxClassNo maximum class number
     * @return Pointer to root/parent node
     */
    DecisionNode *build ( const FeaturePool &fp,
                          const Examples &examples,
                          int maxClassNo );

};



} //namespace

#endif