MedAlgo.h

Go to the documentation of this file.

 
 
#ifndef __MED_ALGO_H__
#define __MED_ALGO_H__
 
#if __GNUC__  >= 5 || (defined(_MSC_VER) && !defined(_DEBUG))
#define NEW_COMPLIER false
#else
#define NEW_COMPLIER false
#endif
 
#include <Logger/Logger/Logger.h>
#include <MedUtils/MedUtils/MedUtils.h>
#include <MedStat/MedStat/MedStat.h>
#include <MedFeat/MedFeat/MedFeat.h>
#include <QRF/QRF/QRF.h>
#include <micNet/micNet/micNet.h>
#include <string.h>
#include <limits.h>
#include <MedProcessTools/MedProcessTools/MedProcessUtils.h>
#include <SerializableObject/SerializableObject/SerializableObject.h>
#include <TQRF/TQRF/TQRF.h>
#include "svm.h"
#include <unordered_map>
#include <random>
#include <map>
#include <string>
 
// Forward Declaration
class MedFeatures;
 
#pragma warning(disable: 4297) //disable annoying " function assumed not to throw an exception but does "
 
using namespace std;
 
//================================================================================
// MedPredictor - wrapper for classical learn/predict algorithms
//================================================================================
 
typedef enum {
    MODEL_LINEAR_MODEL = 0, 
    MODEL_QRF = 1, 
    MODEL_KNN = 3, 
    MODEL_BP = 4, 
    MODEL_MARS = 5, 
    MODEL_GD_LINEAR = 6, 
    MODEL_MULTI_CLASS = 7, 
    MODEL_XGB = 8, 
    MODEL_LASSO = 9, 
    MODEL_MIC_NET = 10, 
    MODEL_BOOSTER = 11, 
    MODEL_DEEP_BIT = 12, 
    MODEL_LIGHTGBM = 13, 
    MODEL_SPECIFIC_GROUPS_MODELS = 14, 
    MODEL_SVM = 15, 
    MODEL_LINEAR_SGD = 16, 
    MODEL_VW = 17, 
    MODEL_TQRF = 18, 
    MODEL_BART = 19, 
    MODEL_EXTERNAL_NN = 20, 
    MODEL_SIMPLE_ENSEMBLE = 21, 
    MODEL_BY_MISSING_VALUES_SUBSET = 22, 
    MODEL_LAST
} MedPredictorTypes;
 
extern unordered_map<int, string> predictor_type_to_name;
MedPredictorTypes predictor_name_to_type(const string& model_name);
 
class MedPredictor : public SerializableObject {
public:
    MedPredictorTypes classifier_type; 
 
    // General constructor
    MedPredictor() {}
    virtual ~MedPredictor() {};
 
    bool transpose_for_learn; 
    bool normalize_for_learn; 
    bool normalize_y_for_learn; 
 
    bool transpose_for_predict; 
    bool normalize_for_predict; 
 
    vector<string> model_features; 
    int features_count = 0;
 
    // Each wrapped algorithm needs to implement the following:
    //.........................................................
    // Init
    virtual int init(void *classifier_params) { return 0; };
    int init_from_string(string initialization_text);
    virtual int init(map<string, string>& mapper);
    virtual int set_params(map<string, string>& mapper) { fprintf(stderr, "????? Using the base class set_params() ?????\n"); fflush(stderr); return 0; };
    virtual void init_defaults() {};
 
 
    virtual int Learn(float *x, float *y, const float *w, int n_samples, int n_ftrs) { return 0; };
 
    virtual int Predict(float *x, float *&preds, int n_samples, int n_ftrs) const { return 0; }
 
    // Print
    virtual void print(FILE *fp, const string& prefix, int level = 0) const;
 
    virtual int n_preds_per_sample() const { return 1; };
 
    virtual int denormalize_model(float *f_avg, float *f_std, float label_avg, float label_std) { return 0; };
 
    // methods relying on virtual methods, and applicable to all predictors: (one can still reimplement in derived class if needed)
    //..............................................................................................................................
 
    int learn(float *x, float *y, int nsamples, int nftrs) { return Learn(x, y, NULL, nsamples, nftrs); }
 
    // simple c++ style learn
 
    virtual int learn(MedMat<float> &x, MedMat<float> &y, const vector<float> &wgts);
    int learn(MedMat<float> &x, MedMat<float> &y) { vector<float> w; return(learn(x, y, w)); }
 
    int learn(MedMat<float> &x, vector<float> &y, const vector<float> &wgts);
    int learn(MedMat<float> &x, vector<float> &y) { vector<float> w; return(learn(x, y, w)); }
 
    int learn(vector<float> &x, vector<float> &y, const vector<float> &wgts, int n_samples, int n_ftrs);
    int learn(vector<float> &x, vector<float> &y, int n_samples, int n_ftrs) { vector<float> w; return learn(x, y, w, n_samples, n_ftrs); }
 
    // simple c++ style predict
    virtual int predict(MedMat<float> &x, vector<float> &preds) const;
    int predict(vector<float> &x, vector<float> &preds, int n_samples, int n_ftrs) const;
    int threaded_predict(MedMat<float> &x, vector<float> &preds, int nthreads) const;
 
    int learn(const MedFeatures& features);
    int learn(const MedFeatures& features, vector<string>& names);
    virtual int predict(MedFeatures& features) const;
 
    virtual void calc_feature_importance(vector<float> &features_importance_scores,
        const string &general_params)
    {
        const MedFeatures *features = NULL;
        calc_feature_importance(features_importance_scores,
            general_params, features);
    }
    virtual void calc_feature_importance(vector<float> &features_importance_scores,
        const string &general_params, const MedFeatures *features)  {
        string model_name = "model_id=" + to_string(classifier_type);
        if (predictor_type_to_name.find(classifier_type) != predictor_type_to_name.end())
            model_name = predictor_type_to_name[classifier_type];
        throw logic_error("ERROR:: operation calc_feature_importance "
            "isn't supported for " + model_name + " yet.");
    };
 
    virtual void calc_feature_contribs(MedMat<float> &x, MedMat<float> &contribs) {
        string model_name = "model_id=" + to_string(classifier_type);
        if (predictor_type_to_name.find(classifier_type) != predictor_type_to_name.end())
            model_name = predictor_type_to_name[classifier_type];
        throw logic_error("ERROR:: operation calc_feature_contribs "
            "isn't supported for " + model_name + " yet.");
    };
 
    virtual void calc_feature_contribs_conditional(MedMat<float> &mat_x_in, unordered_map<string, float> &contiditional_variables, MedMat<float> &mat_x_out, MedMat<float> &mat_contribs)
    {
        string model_name = "model_id=" + to_string(classifier_type);
        if (predictor_type_to_name.find(classifier_type) != predictor_type_to_name.end())
            model_name = predictor_type_to_name[classifier_type];
        throw logic_error("ERROR:: operation calc_feature_contribs_conditional "
            "isn't supported for " + model_name + " yet.");
    }
 
    virtual void export_predictor(const string &output_fname) {
        string model_name = "model_id=" + to_string(classifier_type);
        if (predictor_type_to_name.find(classifier_type) != predictor_type_to_name.end())
            model_name = predictor_type_to_name[classifier_type];
        throw logic_error("ERROR:: operation export_predictor "
            "isn't supported for " + model_name + " yet.");
    }
 
    int learn_prob_calibration(MedMat<float> &x, vector<float> &y,
        vector<float> &min_range, vector<float> &max_range, vector<float> &map_prob, int min_bucket_size = 10000,
        float min_score_jump = 0.001, float min_prob_jump = 0.005, bool fix_prob_order = false);
    int convert_scores_to_prob(const vector<float> &preds, const vector<float> &min_range,
        const vector<float> &max_range, const vector<float> &map_prob, vector<float> &probs) const;
    int learn_prob_calibration(MedMat<float> &x, vector<float> &y, int poly_rank, vector<double> &params, int min_bucket_size = 10000, float min_score_jump = 0.001);
    template<class T, class L> int convert_scores_to_prob(const vector<T> &preds, const vector<double> &params, vector<L> &converted) const;
 
    // init
    static MedPredictor *make_predictor(string model_type);
    static MedPredictor *make_predictor(MedPredictorTypes model_type);
    static MedPredictor *make_predictor(string model_type, string params);
    static MedPredictor *make_predictor(MedPredictorTypes model_type, string params);
 
    virtual bool predict_single_not_implemented() { return false; }
    virtual void prepare_predict_single();
    virtual void predict_single(const vector<float> &x, vector<float> &preds) const;
    virtual void predict_single(const vector<double> &x, vector<double> &preds) const;
    virtual void calc_feature_importance_shap(vector<float> &features_importance_scores, string &importance_type, const MedFeatures *features);
 
    // (De)Serialize
    ADD_CLASS_NAME(MedPredictor)
        ADD_SERIALIZATION_FUNCS(classifier_type)
        void *new_polymorphic(string derived_class_name);
    size_t get_predictor_size();
    size_t predictor_serialize(unsigned char *blob);
 
 
protected:
    // some needed helpers
    void prepare_x_mat(MedMat<float> &x, const vector<float> &wgts, int &nsamples, int &nftrs, bool transpose_needed) const;
    void predict_thread(void *p) const;
 
};
 
 
 
//================================================================
// Unsupervised
//================================================================
 
int KMeans(MedMat<float> &x, int K, MedMat<float> &centers, vector<int> &clusters, MedMat<float> &dists);
int KMeans(MedMat<float> &x, int K, int max_iter, MedMat<float> &centers, vector<int> &clusters, MedMat<float> &dists);
int KMeans(float *x, int nrows, int ncols, int K, float *centers, int *clusters, float *dists);
 
int KMeans(float *x, int nrows, int ncols, int K, int max_iter, float *centers, int *clusters, float *dists, bool verbose_print = true); // actual implemetation routine
 
// PCA
 
int MedPCA(MedMat<float> &x, MedMat<float> &pca_base, vector<float> &varsum);
 
int MedPCA_project(MedMat<float> &x, MedMat<float> &pca_base, int dim, MedMat<float> &projected);
 
 
//=========================================================================================
 
namespace medial {
    namespace models {
        string getParamsInfraModel(void *model);
        void *copyInfraModel(void *model, bool delete_old = true);
        void initInfraModel(void *&model);
        void learnInfraModel(void *model, const vector<vector<float>> &xTrain, vector<float> &y, vector<float> &weights);
        vector<float> predictInfraModel(void *model, const vector<vector<float>> &xTest);
        void get_pids_cv(MedPredictor *pred, MedFeatures &matrix, int nFolds,
            mt19937 &generator, vector<float> &preds);
        void get_cv(MedPredictor *pred, MedFeatures &matrix, int nFolds,
            mt19937 &generator, vector<float> &preds);
    }
    namespace process {
        void compare_populations(const MedFeatures &population1, const MedFeatures &population2,
            const string &name1, const string &name2, const string &output_file,
            const string &predictor_type = "", const string &predictor_init = "", int nfolds = 5, int max_learn = 0);
    }
}
 
 
//=================================================================
// Joining the MedSerialize Wagon
//=================================================================
MEDSERIALIZE_SUPPORT(MedPredictor)
 
#endif