GibbsSampler.h

#ifndef __GIBBS_SAMPLER_H__
#define __GIBBS_SAMPLER_H__
#include <vector>
#include <string>
#include <map>
#include <random>
#include <unordered_map>
#include <SerializableObject/SerializableObject/SerializableObject.h>
#include <MedAlgo/MedAlgo/MedAlgo.h>
#include <MedAlgo/MedAlgo/BinSplitOptimizer.h>
#include "MedProcessTools/MedProcessTools/Calibration.h"
 
using namespace std;
 
template<typename T> class PredictorOrEmpty : public SerializableObject {
public:
    int input_size;
    vector<T> sample_cohort; 
    MedPredictor *predictor; 
    vector<Calibrator> calibrators; 
    vector<float> bin_vals; 
 
    vector<float> cluster_centers; 
    vector<vector<float>> clusters_y; 
 
    PredictorOrEmpty();
    ~PredictorOrEmpty();
 
    T get_sample(vector<T> &x, mt19937 &gen);
 
    ADD_CLASS_NAME(PredictorOrEmpty)
        ADD_SERIALIZATION_FUNCS(input_size, sample_cohort, cluster_centers, clusters_y, predictor, calibrators, bin_vals)
};
 
class Gibbs_Params : public SerializableObject {
public:
    //learn args - kmeans or predictor
    int kmeans; 
    float selection_ratio; 
    int selection_count; 
    bool select_with_repeats; 
    int max_iters; 
 
    string predictor_type; 
    string predictor_args; 
    string num_class_setup; 
    BinSettings bin_settings; 
 
    float calibration_save_ratio; 
    string calibration_string; 
    
    Gibbs_Params();
 
    int init(map<string, string>& map);
 
    ADD_CLASS_NAME(Gibbs_Params)
        ADD_SERIALIZATION_FUNCS(kmeans, selection_ratio, max_iters, select_with_repeats, predictor_type, predictor_args,
            num_class_setup, bin_settings, calibration_save_ratio, calibration_string)
};
 
class GibbsSamplingParams : public SerializableObject {
public:
    //sample args
    int burn_in_count; 
    int jump_between_samples; 
    int samples_count; 
    bool find_real_value_bin; 
 
    GibbsSamplingParams();
    int init(map<string, string>& map);
 
    ADD_CLASS_NAME(GibbsSamplingParams)
    ADD_SERIALIZATION_FUNCS(burn_in_count, jump_between_samples, samples_count, find_real_value_bin)
};
 
template<typename T> class GibbsSampler : public SerializableObject {
private:
    mt19937 _gen;
    bool done_prepare;
public:
    Gibbs_Params params; 
    vector<PredictorOrEmpty<T>> feats_predictors; 
    vector<string> all_feat_names; 
    vector<string> impute_feat_names; 
    vector<vector<T>> uniqu_value_bins; 
 
    GibbsSampler();
 
    void learn_gibbs(const map<string, vector<T>> &cohort_data);
 
    void learn_gibbs(const map<string, vector<T>> &cohort_data, const vector<string> &learn_features, bool skip_missing);
 
    void prepare_predictors();
 
    void get_samples(map<string, vector<T>> &results, const GibbsSamplingParams &sampling_params,
        const vector<bool> *mask = NULL, const vector<T> *mask_values = NULL, bool print_progress = false);
 
    void get_samples(map<string, vector<T>> &results, const GibbsSamplingParams &sampling_params, mt19937 &rnd_gen,
        const vector<bool> *mask = NULL, const vector<T> *mask_values = NULL, bool print_progress = false);
 
    void get_parallel_samples(map<string, vector<T>> &results, const GibbsSamplingParams &sampling_params,
        const vector<bool> *mask = NULL, const vector<T> *mask_values = NULL);
 
    void filter_samples(const map<string, vector<float>> &cohort_data,
        map<string, vector<T>> &results, const string &predictor_type, const string &predictor_args,
        float filter_sens);
 
    int init(map<string, string>& map); 
 
    virtual ~GibbsSampler();
 
    ADD_CLASS_NAME(GibbsSampler<T>)
        ADD_SERIALIZATION_FUNCS(params, feats_predictors, uniqu_value_bins, all_feat_names, impute_feat_names)
};
 
MEDSERIALIZE_SUPPORT(PredictorOrEmpty<float>)
MEDSERIALIZE_SUPPORT(PredictorOrEmpty<double>)
MEDSERIALIZE_SUPPORT(Gibbs_Params)
MEDSERIALIZE_SUPPORT(GibbsSamplingParams)
MEDSERIALIZE_SUPPORT(GibbsSampler<float>)
MEDSERIALIZE_SUPPORT(GibbsSampler<double>)
 
#endif