MedBootstrap.h

#ifndef __MEDBOOTSTRAP_ANALYSIS_H__
#define __MEDBOOTSTRAP_ANALYSIS_H__
#include <unordered_map>
#include <MedStat/MedStat/bootstrap.h>
#include <SerializableObject/SerializableObject/SerializableObject.h>
#include <MedProcessTools/MedProcessTools/MedSamples.h>
#include <MedProcessTools/MedProcessTools/MedFeatures.h>
#include <InfraMed/InfraMed/MedPidRepository.h>
#include <MedUtils/MedUtils/MedRegistry.h>
 
enum class MeasurmentFunctionType {
    calc_npos_nneg = 0,
    calc_only_auc = 1,
    calc_roc_measures_with_inc = 2, 
    calc_multi_class = 3,
    calc_kandel_tau = 4,
    calc_harrell_c_statistic = 5,
    calc_regression = 6
};
class with_registry_args {
public:
    MedRegistry *registry; 
    MedRegistry *registry_censor; 
    MedSamplingYearly *sampler; 
    bool do_kaplan_meir; 
    string rep_path; 
    string json_model; 
    LabelParams labeling_params;
    with_registry_args() {
        do_kaplan_meir = true;
        registry_censor = NULL;
        registry = NULL;
        sampler = NULL;
    }
};
 
class MedBootstrap : public SerializableObject {
public:
    ROC_Params roc_Params; 
    Regression_Params regression_params; 
    Multiclass_Params multiclass_params; 
    map<string, vector<Filter_Param>> filter_cohort; 
    map<string, FilterCohortFunc> additional_cohorts; 
    float sample_ratio; 
    int sample_per_pid; 
    bool sample_patient_label; 
    int sample_seed; 
    int loopCnt; 
    bool is_binary_outcome; 
    bool use_time_control_as_case; 
    bool simTimeWindow;
    float censor_time_factor;
    bool sort_preds_in_multicategory;
    size_t num_categories; 
    vector<pair<MeasurementFunctions, Measurement_Params *>> measurements_with_params;  
 
    void parse_cohort_line(const string &line);
 
    void get_cohort_from_arg(const string &single_cohort);
 
 
    void parse_cohort_file(const string &cohorts_path);
 
    MedBootstrap();
 
    int init(map<string, string>& map);
 
    void clean_feature_name_prefix(map<string, vector<float>> &features);
 
    void prepare_bootstrap(const MedFeatures &features, vector<float> &preds, vector<float> &y, vector<int> &pids,
        map<string, vector<float>> &final_additional_info, vector<int> &preds_order, unordered_map<int, vector<int>> *splits_inds = NULL);
    void prepare_bootstrap(MedSamples &samples, map<string, vector<float>> &additional_info, vector<float> &preds, vector<float> &y, vector<int> &pids, vector<int> &preds_order,
        unordered_map<int, vector<int>> *splits_inds = NULL);
    map<string, map<string, float>> bootstrap(const MedFeatures &features, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
    map<string, map<string, float>> bootstrap(MedSamples &samples, map<string, vector<float>> &additional_info, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
    map<string, map<string, float>> bootstrap(MedSamples &samples, const string &rep_path, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
    map<string, map<string, float>> bootstrap(MedSamples &samples, MedPidRepository &rep, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
 
    void apply_censor(const unordered_map<int, int> &pid_censor_dates, MedSamples &samples);
    void apply_censor(const unordered_map<int, int> &pid_censor_dates, MedFeatures &features);
    void apply_censor(const vector<int> &pids, const vector<int> &censor_dates, MedFeatures &features);
    void apply_censor(const vector<int> &pids, const vector<int> &censor_dates, MedSamples &samples);
 
    void change_sample_autosim(MedSamples &samples, int min_time, int max_time, MedSamples &new_samples);
    void change_sample_autosim(MedFeatures &features, int min_time, int max_time, MedFeatures &new_features);
    MeasurmentFunctionType measurement_function_name_to_type(const string& measurement_function_name);
 
    static unordered_map<string, MeasurmentFunctionType> measurement_function_name_map;
 
    static void filter_bootstrap_cohort(MedFeatures &features, const string &bt_cohort);
    static void filter_bootstrap_cohort(MedPidRepository &bt_repository, MedModel &bt_filters,
        MedSamples &curr_samples, const string &bt_cohort);
    static void filter_bootstrap_cohort(const string &rep, const string &bt_json,
        MedSamples &curr_samples, const string &bt_cohort);
 
    ADD_CLASS_NAME(MedBootstrap)
    ADD_SERIALIZATION_FUNCS(sample_ratio, sample_per_pid, sample_patient_label, sample_seed, loopCnt, roc_Params, filter_cohort, simTimeWindow, multiclass_params, censor_time_factor)
 
private:
    map<string, map<string, float>> bootstrap_base(const vector<float> &preds, const vector<int> &preds_order,  const vector<float> &y, const vector<int> &pids,
        const vector<float> *weights, const map<string, vector<float>> &additional_info);
    map<string, map<string, float>> bootstrap_using_registry(const MedFeatures &features_mat,
        const with_registry_args& args, map<int, map<string, map<string, float>>> *results_per_split = NULL);
    void add_splits_results(const vector<float> &preds, vector<int> &preds_order, const vector<float> &y,
        const vector<int> &pids, const vector<float> *weights, const map<string, vector<float>> &data,
        const unordered_map<int, vector<int>> &splits_inds,
        map<int, map<string, map<string, float>>> &results_per_split);
    bool use_time_window();
    void add_filter_cohorts(const map<string, vector<pair<float, float>>> &parameters_ranges);
    void add_filter_cohorts(const vector<vector<Filter_Param>> &parameters_ranges);
    void sort_index_only(const vector<float> &vec, std::vector<int>::iterator ind_start, std::vector<int>::iterator ind_end);
};
 
class MedBootstrapResult : public SerializableObject {
public:
    MedBootstrap bootstrap_params; 
    map<string, map<string, float>> bootstrap_results;
 
    void bootstrap(MedFeatures &features, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
    void bootstrap(MedSamples &samples, map<string, vector<float>> &additional_info, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
    void bootstrap(MedSamples &samples, const string &rep_path, map<int, map<string, map<string, float>>> *results_per_split = NULL, with_registry_args *registry_args = NULL);
 
    void find_working_points(const map<string, float> &bootstrap_cohort,
        vector<float> &sens_points, vector<float> &pr_points);
 
    void explore_score(float score, map<string, float> &score_measurements,
        const string &string_cohort = "All", float max_search_range = 0.1);
 
    void write_results_to_text_file(const string &path, bool pivot_format = true, const string& run_id = "");
    void read_results_to_text_file(const string &path, bool pivot_format = true);
 
    ADD_CLASS_NAME(MedBootstrapResult)
    ADD_SERIALIZATION_FUNCS(bootstrap_params, bootstrap_results)
private:
    bool find_in_range(const vector<float> &vec, float search, float th);
    void explore_measure(const string &measure_name, float value, map<string, float> &score_measurements,
        const string &string_cohort = "All", float max_search_range = 0.1);
};
 
namespace medial {
    namespace process {
        void make_sim_time_window(const string &cohort_name, const vector<Filter_Param> &filter_p,
            const vector<float> &y, const map<string, vector<float>> &additional_info,
            vector<float> &y_changed, map<string, vector<float>> &cp_info,
            map<string, FilterCohortFunc> &cohorts_t, map<string, void *> &cohort_params_t, float censor_time_factor = 2);
    }
}
 
MEDSERIALIZE_SUPPORT(MedBootstrap)
MEDSERIALIZE_SUPPORT(MedBootstrapResult)
 
#endif