PostProcessor.h

Go to the documentation of this file.

 
#ifndef __POST_PROCESSOR_H__
#define __POST_PROCESSOR_H__
 
#include <vector>
#include <SerializableObject/SerializableObject/SerializableObject.h>
#include "MedSamples.h"
#include "MedModel.h"
#include "Effected_Field.h"
 
typedef enum {
    FTR_POSTPROCESS_MULTI, 
    FTR_POSTPROCESS_CALIBRATOR, 
    FTR_POSTPROCESS_TREE_SHAP, 
    FTR_POSTPROCESS_SHAPLEY, 
    FTR_POSTPROCESS_MISSING_SHAP, 
    FTR_POSTPROCESS_LIME_SHAP, 
    FTR_POSTPROCESS_KNN_EXPLAIN,
    FTR_POSTPROCESS_LINEAR, 
    FTR_POSTPROCESS_ITERATIVE_SET, 
    FTR_POSTPROCESS_AGGREGATE_PREDS, 
    FTR_POSTPROCESS_ADJUST, 
    FTR_POSTPROCESS_FAIRNESS, 
    FTR_POSTPROCESS_LAST
} PostProcessorTypes;
 
using namespace std;
 
class MedModel;
 
 
 
class PostProcessor : public SerializableObject {
public:
    PostProcessorTypes processor_type = PostProcessorTypes::FTR_POSTPROCESS_LAST;
 
    // The following variables are used for enabling model to put aside a subset of the learning
    // set for post-processor learning. Either use_split (put aside all ids within a given split)
    // or use_p (put aside a proportion 0 < p < 1 of the ids) can be given. but not both
    int use_split = -1;
    float use_p = 0.0;
 
    virtual void get_input_fields(vector<Effected_Field> &fields) const {};
    virtual void get_output_fields(vector<Effected_Field> &fields) const {};
 
    virtual void init_post_processor(MedModel& mdl) {};
    virtual void Learn(const MedFeatures &matrix);
    virtual void Apply(MedFeatures &matrix);
 
    void *new_polymorphic(string dname);
 
    static PostProcessor *make_processor(const string &processor_name, const string &params = "");
    static PostProcessor *make_processor(PostProcessorTypes type, const string &params = "");
 
    static PostProcessor *create_processor(string &params);
 
    virtual void dprint(const string &pref) const;
 
    virtual ~PostProcessor() {};
 
    virtual float get_use_p() { return use_p; }
    virtual int get_use_split() { return use_split; }
 
    ADD_CLASS_NAME(PostProcessor)
        ADD_SERIALIZATION_FUNCS(processor_type)
};
PostProcessorTypes post_processor_name_to_type(const string& post_processor);
 
class MultiPostProcessor : public PostProcessor {
public:
    vector<PostProcessor *> post_processors;
    bool call_parallel_learn = false;
    bool call_parallel_apply = false;
 
    MultiPostProcessor() { processor_type = PostProcessorTypes::FTR_POSTPROCESS_MULTI; }
 
    void Learn(const MedFeatures &matrix);
    void Apply(MedFeatures &matrix);
 
    void get_input_fields(vector<Effected_Field> &fields) const;
    void get_output_fields(vector<Effected_Field> &fields) const;
 
    void init_post_processor(MedModel& mdl);
 
    void dprint(const string &pref) const;
 
    ~MultiPostProcessor();
 
    float get_use_p();
    int get_use_split();
 
    ADD_CLASS_NAME(MultiPostProcessor)
        ADD_SERIALIZATION_FUNCS(post_processors)
};
 
MEDSERIALIZE_SUPPORT(PostProcessor)
MEDSERIALIZE_SUPPORT(MultiPostProcessor)
 
#endif