decision_forest.h

Go to the documentation of this file.

// Author: AI Werkstatt (TM)
// (C) Copyright 2019, AI Werkstatt (TM) www.aiwerkstatt.com. All rights reserved.

#ifndef KOHO_DECISION_FOREST_H
#define KOHO_DECISION_FOREST_H

#include "decision_tree.h"

namespace koho {

// =============================================================================
// Decision Forest Classifier
// =============================================================================

    class DecisionForestClassifier {

    protected:
        OutputsIdx_t                            n_outputs;
        std::vector<std::vector<std::string>>   classes;
        std::vector<ClassesIdx_t>               n_classes;
        ClassesIdx_t                            n_classes_max; // just for convenience
        std::vector<std::string>                features;
        FeaturesIdx_t                           n_features;

        // Hyperparameters
        unsigned long                           n_estimators;
        bool                                    bootstrap;
        bool                                    oob_score;
        std::string                             class_balance;
        TreeDepthIdx_t                          max_depth;
        FeaturesIdx_t                           max_features;
        unsigned long                           max_thresholds;
        std::string                             missing_values;

        // Random Number Generator
        RandomState                             random_state;

        // Model
        std::vector<DecisionTreeClassifier>     dtc_; // underlying sub-estimators

        // Performance Characteristics
        double                                  oob_score_; // Out_Of-Bag estimate

    public:

        DecisionForestClassifier(std::vector<std::vector<std::string>> const&   classes,
                                 std::vector<std::string> const&                features,
                                 unsigned long                                  n_estimators = 100,
                                 bool                                           bootstrap = false,
                                 bool                                           oob_score = false,
                                 std::string const&                             class_balance = "balanced",
                                 TreeDepthIdx_t                                 max_depth = 3,
                                 FeaturesIdx_t                                  max_features = 0,
                                 unsigned long                                  max_thresholds = 0,
                                 std::string const&                             missing_values = "None",
                                 long                                           random_state_seed = 0);


        void fit(std::vector<Features_t> &   X,
                 std::vector<Classes_t> &    y);


        void  predict_proba(Features_t*   X,
                            SamplesIdx_t  n_samples,
                            double*       y_prob);


        void  predict(Features_t*   X,
                      SamplesIdx_t  n_samples,
                      Classes_t*    y);


        double score(Features_t*   X,
                     Classes_t*    y,
                     SamplesIdx_t  n_samples);


        void  calculate_feature_importances(double*  importances);


        void  export_graphviz(std::string const& filename, bool rotate=false);


        void export_graphviz(std::string const& filename, unsigned long e, bool rotate);


        std::string  export_text(unsigned long e);


        void  export_serialize(std::string const& filename);


        static  DecisionForestClassifier  import_deserialize(std::string const& filename);

        void  serialize(std::ofstream& fout);
        static  DecisionForestClassifier  deserialize(std::ifstream& fin);
    };

} // namespace koho

#endif