FairnessPostProcessor.h

#ifndef __FAIRNESS_POSTPROCESSOR_H__
#define __FAIRNESS_POSTPROCESSOR_H__
 
#include "PostProcessor.h"
#include <Logger/Logger/Logger.h>
 
enum Cutoff_Type {
    Score = 0,
    PR = 1,
    Sens = 2
};
 
extern unordered_map<string, int> map_target_type;
enum Fairness_Target_Type {
    SENS = 0,
    SPEC = 1
};
 
class Cutoff_Constraint : public SerializableObject {
public:
    Cutoff_Type type; 
    float value; 
 
    void set_type(const string &t);
 
    ADD_CLASS_NAME(Cutoff_Constraint)
        ADD_SERIALIZATION_FUNCS(type, value)
};
 
class FairnessPostProcessor : public PostProcessor {
private:
    unordered_map<float, vector<float>> group_to_score_cutoffs_ranges;
    unordered_map<float, vector<float>> group_to_factors;
    unordered_map<float, vector<float>> group_to_bias;
    bool feature_gen_init = false;
public:
    string feature_name; 
    string model_json; 
    float reference_group_val = MED_MAT_MISSING_VALUE; 
    Fairness_Target_Type fairness_target_type; 
    vector<Cutoff_Constraint> constraints; 
    double resulotion = 0.1; 
    double allow_distance_score = 1.0; 
    double allow_distance_target = 5.0; 
    double allow_distance_cutoff_constraint = 1.0; 
    int score_bin_count = 5000; 
    float score_resulotion = 0; 
 
    MedPidRepository *p_rep; 
    MedModel group_feature_gen_model; 
    string resolved_name; 
 
    FairnessPostProcessor() { processor_type = PostProcessorTypes::FTR_POSTPROCESS_FAIRNESS; };
    ~FairnessPostProcessor() {};
    void init_post_processor(MedModel& mdl) { p_rep = mdl.p_rep; }
 
    void parse_constrains(const string &s); 
 
    void get_input_fields(vector<Effected_Field> &fields) const;
    void get_output_fields(vector<Effected_Field> &fields) const;
 
    int init(map<string, string> &mapper);
 
    void Learn(const MedFeatures &matrix);
    void Apply(MedFeatures &matrix);
 
    void dprint(const string &pref) const;
 
    ADD_CLASS_NAME(FairnessPostProcessor)
        ADD_SERIALIZATION_FUNCS(processor_type, feature_name, resolved_name, reference_group_val,
            group_feature_gen_model, constraints, fairness_target_type, resulotion,
            group_to_score_cutoffs_ranges, group_to_factors, group_to_bias, allow_distance_cutoff_constraint,
            allow_distance_target, allow_distance_score, score_bin_count, score_resulotion)
};
 
MEDSERIALIZE_SUPPORT(Cutoff_Constraint)
MEDSERIALIZE_SUPPORT(FairnessPostProcessor)
 
#endif