TrainNodeCvRF.h

// Random Forest (based on OpenCV) training class interface
// Written by Sergey G. Kosov in 2012 for Project X
#pragma once

#include "TrainNode.h"

namespace DirectGraphicalModels
{
    class CRForest;

    typedef struct TrainNodeCvRFParams {
        int     max_depth;                          
        int     min_sample_count;                   
        float   regression_accuracy;                
        bool    use_surrogates;                     
        int     max_categories;                     
        bool    calc_var_importance;                
        int     nactive_vars;                       
        int     maxCount;                           
        double  epsilon;                            
        int     term_criteria_type;                 
        int     maxSamples;                         

        TrainNodeCvRFParams() {}
        TrainNodeCvRFParams(int _max_depth, int _min_sample_count, float _regression_accuracy, bool _use_surrogates, int _max_categories, bool _calc_var_importance, int _nactive_vars, int _maxCount, double _epsilon, int _term_criteria_type, int _maxSamples) : max_depth(_max_depth), min_sample_count(_min_sample_count), regression_accuracy(_regression_accuracy), use_surrogates(_use_surrogates), max_categories(_max_categories), calc_var_importance(_calc_var_importance), nactive_vars(_nactive_vars), maxCount(_maxCount), epsilon(_epsilon), term_criteria_type(_term_criteria_type), maxSamples(_maxSamples) {}
    } TrainNodeCvRFParams;

    const TrainNodeCvRFParams TRAIN_NODE_CV_RF_PARAMS_DEFAULT = TrainNodeCvRFParams(
                                                                25,     // Max depth
                                                                5,      // Min sample count (1% of all data)
                                                                0,      // Regression accuracy (0 means N/A here)
                                                                false,  // Compute surrogate split, no missing data
                                                                15,     // Max number of categories (use sub-optimal algorithm for larger numbers) 
                                                                false,  // Calculate variable importance 
                                                                4,      // Number of variables randomly selected at node and used to find the best split(s). 0 means sqrt(nFeatures) 
                                                                100,    // Max number of trees in the forest (time / accuracy)
                                                                0.01,   // Forest accuracy
                                                                TermCriteria::MAX_ITER | TermCriteria::EPS, // Termination cirteria (according the the two previous parameters)
                                                                0       // Maximum number of samples to be used in training. 0 means using all the samples
                                                                );

    // =========================== OpenCV RF Train Class ===========================
    class CTrainNodeCvRF : public CTrainNode
    {
    public:
        DllExport CTrainNodeCvRF(byte nStates, word nFeatures, TrainNodeCvRFParams params = TRAIN_NODE_CV_RF_PARAMS_DEFAULT);
        DllExport CTrainNodeCvRF(byte nStates, word nFeatures, int maxSamples);
        DllExport ~CTrainNodeCvRF(void);

        DllExport void  reset(void);        
        DllExport void  save(const std::string &path, const std::string &name = std::string(), short idx = -1) const; 
        DllExport void  load(const std::string &path, const std::string &name = std::string(), short idx = -1); 
    
        DllExport void  addFeatureVec(const Mat &featureVector, byte gt);   
        DllExport void  train(bool doClean = false);

        DllExport Mat   getFeatureImportance(void) const; 

    
    protected:
        DllExport void saveFile(FILE *pFile) const { }
        DllExport void loadFile(FILE *pFile) { }
        DllExport void calculateNodePotentials(const Mat &featureVector, Mat &potential, Mat &mask) const;


    protected:
        Ptr<CRForest>   m_pRF;                              


    private:
        void            init(TrainNodeCvRFParams params);   // This function is called by both constructors
        
        
    private:        
        vec_mat_t       m_vSamplesAcc;                      // = vec_mat_t(nStates);    // Samples container for all states
        vec_int_t       m_vNumInputSamples;                 // = vec_int_t(nStates, 0); // Amount of input samples for all states
        int             m_maxSamples;                       // = INFINITY;              // for optimisation purposes
    };
}