training_and_predicting.py

# %%
import pandas as pd
import yaml
import numpy as np
import hpo_fpr
import os
import pickle
from sklearn import metrics
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
from pathlib import Path

with open('../data/dataset_cfg.yaml', 'r') as infile:
    data_cfg = yaml.safe_load(infile)

with open('cfg.yaml', 'r') as infile:
    cfg = yaml.safe_load(infile)

cat_dict = data_cfg['categorical_dict']

def cat_checker(data, features, cat_dict):
    new_data = data.copy()
    for feature in features:
        if new_data[feature].dtype != 'category':
            new_data[feature] = pd.Categorical(new_data[feature].values, categories=cat_dict[feature])
        elif new_data[feature].dtype.categories.to_list() != cat_dict[feature]:
            new_data[feature] = pd.Categorical(new_data[feature].values, categories=cat_dict[feature])
    
    return new_data

# DATA LOADING -------------------------------------------------------------------------------------
data = pd.read_csv('../../Data_and_models/data/Base.csv')
LABEL_COL = data_cfg['data_cols']['label']
TIMESTAMP_COL = data_cfg['data_cols']['timestamp']
PROTECTED_COL = data_cfg['data_cols']['protected']
CATEGORICAL_COLS = data_cfg['data_cols']['categorical']

data.sort_values(by = 'month', inplace = True)
data.reset_index(inplace=True)
data.drop(columns = 'index', inplace = True)
data.index.rename('case_id', inplace=True)
data.loc[:,data_cfg['data_cols']['categorical']] = data.loc[:,data_cfg['data_cols']['categorical']].astype('category')

data = cat_checker(data, CATEGORICAL_COLS, cat_dict)

def splitter(df, timestamp_col, beginning: int, end: int):
    return df[
        (df[timestamp_col] >= beginning) &
        (df[timestamp_col] < end)].copy()

train = splitter(data, TIMESTAMP_COL, *cfg['splits']['train']).drop(columns=TIMESTAMP_COL)
ml_val = splitter(data, TIMESTAMP_COL, *cfg['splits']['ml_val']).drop(columns=TIMESTAMP_COL)
deployment = splitter(data, TIMESTAMP_COL, *cfg['splits']['deployment']).drop(columns=TIMESTAMP_COL)


# %%
def fpr_thresh(y_true, y_pred):
    results = pd.DataFrame()
    results["true"] = y_true
    results["score"] = y_pred

    temp = results.sort_values(by="score", ascending=False)
    FPR = 0.05
    N = (temp["true"] == 0).sum()
    FP = round(FPR * N)
    aux = temp[temp["true"] == 0]

    threshold = aux.iloc[FP - 1, 1]

    y_pred = np.where(results["score"] >= threshold, 1, 0)
    tpr = metrics.recall_score(y_true, y_pred)

    return tpr, threshold

X_train = train.drop(columns = 'fraud_bool')
y_train = train['fraud_bool']

X_val = ml_val.drop(columns = 'fraud_bool') 
y_val = ml_val['fraud_bool']

if not (os.path.exists('../../Data_and_models/alert_model/best_model.pickle')):
    opt = hpo_fpr.HPO(X_train,X_val,y_train,y_val, method = 'TPE', path = f"../../Data_and_models/alert_model/")
    opt.initialize_optimizer(CATEGORICAL_COLS, 25)

with open('../../Data_and_models/alert_model//best_model.pickle', 'rb') as infile:
        model = pickle.load(infile)

y_pred = model.predict_proba(X_val)
y_pred = y_pred[:,1]
roc_curve_clf = dict()
rec_at_5, thresh = fpr_thresh(y_val, y_pred)


X_test = deployment.drop(columns = 'fraud_bool')
y_test = deployment['fraud_bool']
y_pred = model.predict_proba(X_test)
y_pred = y_pred[:,1]

roc_curve_clf = dict()
roc_curve_clf['fpr'],roc_curve_clf['tpr'],roc_curve_clf['thr'] = metrics.roc_curve(y_test, y_pred)
pred = np.where(y_pred >= thresh, 1, 0)
tpr = metrics.recall_score(y_test, pred)

deployment['model_score'] = y_pred
deployment.to_parquet('../../Data_and_models/data/BAF_deployment_score.parquet')

model_perf_test = pd.DataFrame(index = deployment.index)
model_perf_test['model_pred'] = (deployment['model_score'] >= thresh).astype(int)
model_perf_test['label'] = deployment['fraud_bool']

tn, fp, fn, tp = confusion_matrix(model_perf_test['label'], model_perf_test['model_pred']).ravel()
fpr_dep = fp/(fp + tn)
model_perf_test_o = model_perf_test.loc[deployment['customer_age']>= 50]
model_perf_test_y = model_perf_test.loc[deployment['customer_age']< 50]



tn, fp, fn, tp = confusion_matrix(model_perf_test_o['label'], model_perf_test_o['model_pred']).ravel()
fpr_o = fp/(fp+tn)
tn, fp, fn, tp = confusion_matrix(model_perf_test_y['label'], model_perf_test_y['model_pred']).ravel()
fpr_y = fp/(fp+tn)

disparity = (fpr_o-fpr_y)

model_properties = {'fpr':0.05,
                    'fnr': 1 - tpr,
                    'threshold': thresh,
                    'disparity': disparity}


file_to_store = open("../../Data_and_models/alert_model/model_properties.pickle", "wb")
pickle.dump(model_properties, file_to_store)
file_to_store.close()