randomForestBase.hpp

Go to the documentation of this file.

#ifndef RANDOMFORESTBASE_HPP
#define RANDOMFORESTBASE_HPP

#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <array>
#include <random>

namespace canopy
{

template <class TDerived, class TLabel, class TNodeDist, class TOutputDist, unsigned TNumParams>
class randomForestBase
{
    public:
        // Methods
        // --------
        randomForestBase();

        randomForestBase(const int num_trees, const int num_levels); // constructor

        bool readFromFile(const std::string filename, const int trees_used = -1, const int max_depth_used = -1);

        bool writeToFile(const std::string filename) const;

        bool isValid() const;

        void setFeatureDefinitionString(const std::string& header_str, const std::string& feat_str);

        void getFeatureDefinitionString(std::string &feat_str) const;

        template <class TIdIterator, class TLabelIterator, class TFeatureFunctor, class TParameterFunctor>
        void train(const TIdIterator first_id, const TIdIterator last_id, const TLabelIterator first_label, TFeatureFunctor&& feature_functor, TParameterFunctor&& parameter_functor, const unsigned num_param_combos_to_test, const bool bagging = true, const float bag_proportion = C_DEFAULT_BAGGING_PROPORTION, const bool fit_split_nodes = true, const unsigned min_training_data = C_DEFAULT_MIN_TRAINING_DATA);

        template<class TIdIterator, class TOutputIterator, class TFeatureFunctor>
        void predictDistGroupwise(TIdIterator first_id, const TIdIterator last_id, TOutputIterator out_it, TFeatureFunctor&& feature_functor) const;

        template<class TIdIterator, class TOutputIterator, class TFeatureFunctor>
        void predictDistSingle(TIdIterator first_id, const TIdIterator last_id, TOutputIterator out_it, TFeatureFunctor&& feature_functor) const;

        template <class TIdIterator, class TLabelIterator, class TOutputIterator, class TFeatureFunctor>
        void probabilityGroupwise(TIdIterator first_id, const TIdIterator last_id, TLabelIterator label_it, TOutputIterator out_it, const bool single_label, TFeatureFunctor&& feature_functor) const;

        template <class TIdIterator, class TLabelIterator, class TOutputIterator, class TFeatureFunctor>
        void probabilitySingle(TIdIterator first_id, const TIdIterator last_id, TLabelIterator label_it, TOutputIterator out_it, const bool single_label, TFeatureFunctor&& feature_functor) const;

        template <class TIdIterator, class TLabelIterator, class TOutputIterator, class TBinaryFunction, class TFeatureFunctor, class TPDFFunctor>
        void probabilityGroupwiseBase(TIdIterator first_id, const TIdIterator last_id, TLabelIterator label_it, TOutputIterator out_it, const bool single_label, TBinaryFunction&& binary_function, TFeatureFunctor&& feature_functor, TPDFFunctor&& pdf_functor) const;

        template <class TIdIterator, class TLabelIterator, class TOutputIterator, class TBinaryFunction, class TFeatureFunctor, class TPDFFunctor>
        void probabilitySingleBase(TIdIterator first_id, const TIdIterator last_id, TLabelIterator label_it, TOutputIterator out_it, const bool single_label, TBinaryFunction&& binary_function, TFeatureFunctor&& feature_functor, TPDFFunctor&& pdf_functor) const;

    private:
        // Methods
        // -------
        void allocateForestMemory();

        void initialise();

        template <class TIdIterator, class TLabelIterator>
        void fitLeaf(const int t, const int n, const std::vector<int>& nodebag, const TIdIterator first_id, const TLabelIterator first_label);

    protected:

        // Types
        // -----

        struct node
        {
            std::array<int,TNumParams> params; 
            bool is_leaf; 
            float thresh; 
            std::vector<TNodeDist> post; 
            node(): is_leaf(false), thresh(0.0) {} 
        };

        struct tree
        {
            std::vector<node> nodes; 
        };

        struct scoreInternalIndexStruct
        {
            float score; 
            int id; 

            scoreInternalIndexStruct(const float score, const int id): score(score), id(id) {}
        };

        class derivedProxy: public TDerived
        {
            friend randomForestBase;
        };

        // Methods
        // -------

        template<class TIdIterator, class TFeatureFunctor>
        void findLeavesGroupwise(TIdIterator first_id, const TIdIterator last_id, const int treenum, std::vector<const TNodeDist*>& leaves, TFeatureFunctor&& feature_functor) const;

        template<class TId, class TFeatureFunctor>
        const TNodeDist* findLeafSingle(const TId id, const int treenum, TFeatureFunctor&& feature_functor) const;

        template <class TLabelIterator>
        static double fastDiscreteEntropy(const std::vector<int>& internal_index, const int n_labels, const TLabelIterator first_label, const std::vector<double>& xlogx_precalc);

        template <class TLabelIterator>
        static int fastDiscreteEntropySplit(const std::vector<scoreInternalIndexStruct>& data_structs, const int n_labels, const TLabelIterator first_label, const std::vector<double>& xlogx_precalc, double& best_split_impurity, float& thresh);

        static std::vector<double> preCalculateXlogX(const int N);

        // Data
        // ----
        int n_trees; 
        int n_levels; 
        int n_nodes; 
        bool valid; 
        bool fit_split_nodes; 
        std::vector<tree> forest; 
        std::string feature_header; 
        std::string feature_string; 
        std::default_random_engine rand_engine; 
        std::uniform_int_distribution<int> uni_dist; 

        // Constants
        // ---------
        static constexpr int C_DEFAULT_MIN_TRAINING_DATA = 50; 
        static constexpr float C_DEFAULT_BAGGING_PROPORTION = 0.5; 

};

} // end of namespace

// Include template class definition
#include <canopy/randomForestBase/randomForestBase.tpp>

// End include guard
#endif