test COMPAS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wasserstein Pareto Frontier Experiment on COMPAS Data Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Data\n",
    "The experiment used the COMPAS data set as in \"Optimized Pre-Processing for Discrimination Prevention\" by Calmon and etc. for comparison purpose: https://github.com/fair-preprocessing/nips2017/tree/master/compas/experiment_data2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.interpolate import interp1d\n",
    "from tqdm import tqdm\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC, LinearSVC\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import confusion_matrix, roc_auc_score, auc, classification_report, roc_curve\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from matplotlib import pyplot\n",
    "from scipy.linalg import sqrtm\n",
    "from matplotlib import gridspec\n",
    "from matplotlib.patches import Rectangle\n",
    "\n",
    "# import data\n",
    "path =r'/Users/shizhouxu/Documents/LIBRARY/Python/Fair_L2_Supervised_Learning/experiment_data_compass/' # use your path\n",
    "train_0 = pd.read_csv(path + \"train_0.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_1 = pd.read_csv(path + \"train_1.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_2 = pd.read_csv(path + \"train_2.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_3 = pd.read_csv(path + \"train_3.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_4 = pd.read_csv(path + \"train_4.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_0 = pd.read_csv(path + \"test_0.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_1 = pd.read_csv(path + \"test_1.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_2 = pd.read_csv(path + \"test_2.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_3 = pd.read_csv(path + \"test_3.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_4 = pd.read_csv(path + \"test_4.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_new_0 = pd.read_csv(path + \"train_new_0.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_new_1 = pd.read_csv(path + \"train_new_1.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_new_2 = pd.read_csv(path + \"train_new_2.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_new_3 = pd.read_csv(path + \"train_new_3.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "train_new_4 = pd.read_csv(path + \"train_new_4.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_new_0 = pd.read_csv(path + \"test_new_0.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_new_1 = pd.read_csv(path + \"test_new_1.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_new_2 = pd.read_csv(path + \"test_new_2.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_new_3 = pd.read_csv(path + \"test_new_3.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "test_new_4 = pd.read_csv(path + \"test_new_4.csv\",index_col=None, header=0, usecols=range(1,6))\n",
    "\n",
    "# all available data variables: features = ['race','age_cat','c_charge_degree','priors_count','is_recid']\n",
    "features = ['race','age_cat','c_charge_degree','priors_count','is_recid']\n",
    "# sensitive variable: Z_features = ['race']\n",
    "Z_features = ['race']\n",
    "# dependnet variable: Y_features = ['is_recid']\n",
    "Y_features = ['is_recid']\n",
    "# independnet variable: X_features = ['age_cat', 'c_charge_degree','priors_count']\n",
    "X_features = ['age_cat', 'c_charge_degree','priors_count']\n",
    "\n",
    "# combine the data by train/test category\n",
    "TrainList=[train_0,train_1,train_2,train_3,train_4]\n",
    "TestList=[test_0,test_1,test_2,test_3,test_4]\n",
    "TrainNewList=[train_new_0,train_new_1,train_new_2,train_new_3,train_new_4]\n",
    "TestNewList=[test_new_0,test_new_1,test_new_2,test_new_3,test_new_4]\n",
    "\n",
    "# data set combined: df\n",
    "ord_enc = OrdinalEncoder()\n",
    "df = pd.concat([train_0,train_1,train_2,train_3,train_4,test_0,test_1,test_2,test_3,test_4])\n",
    "# data set further excluding the sensitive variable: df_delete\n",
    "df_delete = df.drop('race',axis = 1)\n",
    "# sensitive variable Z: gender\n",
    "race = df['race']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute the Wasserstein Pseudo-barycenter for X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-2-3c40a39d3d29>:60: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  train_new[gender_train_i == 'African-American',:] = (train[gender_train_i == 'African-American',:] - X_A_mean) @ T_X_A.T + X_mean\n",
      "<ipython-input-2-3c40a39d3d29>:61: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  train_new[gender_train_i == 'Caucasian',:] = (train[gender_train_i == 'Caucasian',:] - X_C_mean) @ T_X_C.T + X_mean\n",
      "<ipython-input-2-3c40a39d3d29>:62: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  test_new[gender_test_i == 'African-American',:] = (test[gender_test_i == 'African-American',:] - X_A_mean) @ T_X_A.T + X_mean\n",
      "<ipython-input-2-3c40a39d3d29>:63: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  test_new[gender_test_i == 'Caucasian',:] = (test[gender_test_i == 'Caucasian',:] - X_C_mean) @ T_X_C.T + X_mean\n"
     ]
    }
   ],
   "source": [
    "# independent variable: X\n",
    "X = np.delete(np.array(pd.get_dummies(df[X_features])),[4],axis = 1)\n",
    "# dependent variable: Y\n",
    "Y = np.array(pd.get_dummies(df[Y_features]))\n",
    "\n",
    "# mean of X and Y: X_mean, Y_mean\n",
    "X_mean = np.mean(X,axis = 0)\n",
    "Y_mean = np.mean(Y)\n",
    "\n",
    "# covariance (matrix) of X and Y: X_cov, Y_cov\n",
    "X_cov = np.cov(X.T)\n",
    "Y_cov = np.cov(Y.T)\n",
    "\n",
    "# marginal (conditional) dependent variables: X_male, Y_male\n",
    "X_A = X[race == 'African-American',:]\n",
    "Y_A = Y[race == 'African-American']\n",
    "X_C = X[race == 'Caucasian',:]\n",
    "Y_C = Y[race == 'Caucasian']\n",
    "\n",
    "# marginal mean: X_(fe)male_mean, Y_(fe)male_mean\n",
    "X_A_mean = np.average(X_A, axis = 0)\n",
    "Y_A_mean = np.average(Y_A)\n",
    "X_C_mean = np.average(X_C, axis = 0)\n",
    "Y_C_mean = np.average(Y_C)\n",
    "\n",
    "# marginal covariance: X_(fe)male_cov, Y_(fe)male_cov, \n",
    "X_A_cov = np.cov(X_A.T)\n",
    "Y_A_cov = np.cov(Y_A.T)\n",
    "X_C_cov = np.cov(X_C.T)\n",
    "Y_C_cov = np.cov(Y_C.T)\n",
    "\n",
    "# cross-covariance (matrix) between Y and X: yX_(fe)male_cov\n",
    "yX_A_cov = np.cov(Y_A.T, X_A.T)[range(len(Y[0,:]),len(Y[0,:]) + len(X[0,:])),0]\n",
    "yX_C_cov = np.cov(Y_C.T, X_C.T)[range(len(Y[0,:]),len(Y[0,:]) + len(X[0,:])),0]\n",
    "\n",
    "# algorithm 1, step 1: iterative process to the independent barycenter covariance matrix with stop cirterion error equals 0.00000001\n",
    "sample_size = len(X[:,0])\n",
    "X_bar = np.random.rand(len(X[0,:]),len(X[0,:])) # random initialization for the covariance\n",
    "eps = 10 # initialization for the stop variable\n",
    "\n",
    "while eps > 0.00000001:\n",
    "    X_new = ((len(X_A[:,0])/sample_size) * sqrtm(sqrtm(X_bar)@X_A_cov@sqrtm(X_bar))) + ((len(X_C[:,0])/sample_size) * sqrtm(sqrtm(X_bar)@X_C_cov@sqrtm(X_bar)))\n",
    "    eps = np.linalg.norm(X_bar - X_new)\n",
    "    X_bar = X_new\n",
    "    \n",
    "# algorithm 1, step 2: the corresponding Brenier's map for marginals of X: T_X_(fe)male\n",
    "T_X_A = np.linalg.inv(sqrtm(X_A_cov)) @ sqrtm( sqrtm(X_A_cov) @ X_bar @ sqrtm(X_A_cov) ) @ np.linalg.inv(sqrtm(X_A_cov))\n",
    "T_X_C = np.linalg.inv(sqrtm(X_C_cov)) @ sqrtm( sqrtm(X_C_cov) @ X_bar @ sqrtm(X_C_cov) ) @ np.linalg.inv(sqrtm(X_C_cov))\n",
    "\n",
    "# wasserstein pseudo-barycenter for X separated in train/test categories: X_TrainFairList, X_TestFairList\n",
    "X_TrainFairList = []\n",
    "X_TestFairList = []\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    train = np.delete(np.array(pd.get_dummies(TrainList[i][X_features])),[4],axis = 1)\n",
    "    test = np.delete(np.array(pd.get_dummies(TestList[i][X_features])),[4],axis = 1)\n",
    "    gender_train_i = np.array(TrainList[i][Z_features]).T[0,:]\n",
    "    gender_test_i = np.array(TestList[i][Z_features]).T[0,:]\n",
    "    train_new = np.random.rand(train.shape[0],train.shape[1])\n",
    "    test_new = np.random.rand(test.shape[0],test.shape[1])\n",
    "    train_new[gender_train_i == 'African-American',:] = (train[gender_train_i == 'African-American',:] - X_A_mean) @ T_X_A.T + X_mean\n",
    "    train_new[gender_train_i == 'Caucasian',:] = (train[gender_train_i == 'Caucasian',:] - X_C_mean) @ T_X_C.T + X_mean\n",
    "    test_new[gender_test_i == 'African-American',:] = (test[gender_test_i == 'African-American',:] - X_A_mean) @ T_X_A.T + X_mean\n",
    "    test_new[gender_test_i == 'Caucasian',:] = (test[gender_test_i == 'Caucasian',:] - X_C_mean) @ T_X_C.T + X_mean\n",
    "    X_TrainFairList.append(train_new)\n",
    "    X_TestFairList.append(test_new)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute the Wasserstein Pseudo-barycenter for E(Y|X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wasserstein pseudo-barycenter for X: X_fair\n",
    "X_fair = np.concatenate([X_TrainFairList[0],X_TrainFairList[1],X_TrainFairList[2],X_TrainFairList[3],X_TrainFairList[4],X_TestFairList[0],X_TestFairList[1],X_TestFairList[2],X_TestFairList[3],X_TestFairList[4]])\n",
    "\n",
    "# marginal (conditional) X_fair: X_fair_(fe)male\n",
    "X_fair_A = X_fair[race == 'African-American',:]\n",
    "X_fair_C = X_fair[race == 'Caucasian',:]\n",
    "\n",
    "# marginal means for X_fair: X_fair_(fe)male_mean\n",
    "X_fair_A_mean = np.average(X_fair_A, axis = 0)\n",
    "X_fair_C_mean = np.average(X_fair_C, axis = 0)\n",
    "\n",
    "# marginal covariance for X_fair: X_fair_(fe)male_cov\n",
    "X_fair_A_cov = np.cov(X_fair_A.T)\n",
    "X_fair_C_cov = np.cov(X_fair_C.T)\n",
    "# cross-covariance between Y and X_fair: yX_fair_(fe)male_cov\n",
    "yX_fair_A_cov = np.cov(Y_A.T, X_fair_A.T)[range(1,8),0]\n",
    "yX_fair_C_cov = np.cov(Y_C.T, X_fair_C.T)[range(1,8),0]\n",
    "\n",
    "# covariance of marginal E(Y|X) in Gaussian case: yoX_(fe)male_cov\n",
    "# which is also the optimal linear estimation of covariance of E(Y|X) in general distribution case\n",
    "yoX_A_cov = yX_fair_A_cov@np.linalg.inv(X_fair_A_cov)@yX_fair_A_cov.T\n",
    "yoX_C_cov = yX_fair_C_cov@np.linalg.inv(X_fair_C_cov)@yX_fair_C_cov.T\n",
    "\n",
    "# algorithm 2, step 1: iterative process to the dependent barycenter covariance matrix with stop cirterion error equals 0.00000000000000000001\n",
    "Y_bar = np.random.rand()\n",
    "eps = 10\n",
    "while eps > 0.00000000000000000001:\n",
    "    Y_new = ((len(X_A[:,0])/sample_size) * np.sqrt(np.sqrt(Y_bar)*yoX_A_cov*np.sqrt(Y_bar))) + ((len(X_C[:,0])/sample_size) * np.sqrt(np.sqrt(Y_bar)*yoX_C_cov*np.sqrt(Y_bar)))\n",
    "    eps = Y_bar - Y_new\n",
    "    Y_bar = Y_new\n",
    "\n",
    "# algorithm 2, step 2: the corresponding Brenier's map for marginals of E(y|X)\n",
    "T_Y_A = (1/np.sqrt(yoX_A_cov)) * np.sqrt( np.sqrt(yoX_A_cov) * Y_bar * np.sqrt(yoX_A_cov) ) * (1/np.sqrt(yoX_A_cov))\n",
    "T_Y_C = (1/np.sqrt(yoX_C_cov)) * np.sqrt( np.sqrt(yoX_C_cov) * Y_bar * np.sqrt(yoX_C_cov) ) * (1/np.sqrt(yoX_C_cov))\n",
    "\n",
    "# wasserstein pseudo-barycenter for Y separated in train/test categories: Y_TrainFairList, Y_TestFairList\n",
    "Y_TrainFairList = []\n",
    "Y_TestFairList = []\n",
    "for i in range(0,len(TrainList)):\n",
    "    train = np.array(pd.get_dummies(TrainList[i][Y_features]))\n",
    "    test = np.array(pd.get_dummies(TestList[i][Y_features]))\n",
    "    train_new = np.random.rand(len(train.T[0,:]))\n",
    "    test_new = np.random.rand(len(test.T[0,:]))\n",
    "    gender_train_i = np.array(TrainList[i][Z_features]).T[0,:]\n",
    "    gender_test_i = np.array(TestList[i][Z_features]).T[0,:]\n",
    "    train_new[gender_train_i == 'African-American'] = ((train[gender_train_i == 'African-American'] - Y_A_mean) * T_Y_A.T + Y_mean).T[0,:]\n",
    "    train_new[gender_train_i == 'Caucasian'] = ((train[gender_train_i == 'Caucasian'] - Y_C_mean) * T_Y_C.T + Y_mean).T[0,:]\n",
    "    test_new[gender_test_i == 'African-American'] = ((test[gender_test_i == 'African-American'] - Y_A_mean) * T_Y_A.T + Y_mean).T[0,:]\n",
    "    test_new[gender_test_i == 'Caucasian'] = ((test[gender_test_i == 'Caucasian'] - Y_C_mean) * T_Y_C.T + Y_mean).T[0,:]\n",
    "    Y_TrainFairList.append(train_new)\n",
    "    Y_TestFairList.append(test_new)\n",
    "\n",
    "# Algorithm 2, step 4: reshape the dependent pseudo-barycenter to binary variable for logit regression\n",
    "fair_value = np.unique(Y_TrainFairList[0])\n",
    "Y_prob = (fair_value - np.min(fair_value))/(np.max(fair_value) - np.min(fair_value))\n",
    "\n",
    "for j in range(0,len(Y_TrainFairList)):\n",
    "    for i in range(0,len(fair_value)):\n",
    "        Y_TrainFairList[j][Y_TrainFairList[j] == fair_value[i]] = np.random.binomial(size = len(np.where(Y_TrainFairList[j] == fair_value[i])[0]),n = 1,p = Y_prob[i])\n",
    "        Y_TestFairList[j][Y_TestFairList[j] == fair_value[i]] = np.random.binomial(size = len(np.where(Y_TestFairList[j] == fair_value[i])[0]),n = 1,p = Y_prob[i])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.6806313530891307,\n",
       "  0.6936874964078394,\n",
       "  0.6839222583134433,\n",
       "  0.6911424760658474,\n",
       "  0.6941297797546452],\n",
       " [0.022847888019631668,\n",
       "  0.07712905884673638,\n",
       "  0.02425321178359141,\n",
       "  0.0030125379534782226,\n",
       "  0.04921958364942469])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random forest test for the fair representation of data (barycenter pair)\n",
    "RFModelsAUC=[]\n",
    "RFTestPreds=[]\n",
    "test_disc=[]\n",
    "for i in range(0,len(TrainList)): \n",
    "    rf=RandomForestClassifier()\n",
    "    rf.fit(X_TrainFairList[i],Y_TrainFairList[i])\n",
    "    proba=rf.predict_proba(X_TestFairList[i])\n",
    "    ytrue=TestList[i][Y_features]\n",
    "    testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "    RFModelsAUC.append(testauc)\n",
    "    temp=TestList[i][Z_features+X_features+Y_features]\n",
    "    temp['pred']=proba[:,1]\n",
    "    mean = temp.groupby(Z_features)['pred'].mean()\n",
    "    v = mean.values\n",
    "    v = v.reshape(len(v),1)\n",
    "    ratio_df = pd.DataFrame(v/v.transpose(),index=mean.index,columns=mean.index )\n",
    "    ratio_df_arr=np.asarray(np.abs(1-ratio_df))\n",
    "    maxdisc=np.amax(ratio_df_arr)\n",
    "    test_disc.append(maxdisc)   \n",
    "\n",
    "RFres_Pseudobary = (RFModelsAUC, RFTestPreds)\n",
    "RFDisc_Pseudobary = test_disc\n",
    "\n",
    "RFModelsAUC, RFDisc_Pseudobary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.695320825394775,\n",
       "  0.6932133312259325,\n",
       "  0.6875186188826876,\n",
       "  0.6989617449012975,\n",
       "  0.6970209484181076],\n",
       " [0.004480557075632108,\n",
       "  0.023564508528626904,\n",
       "  0.016514309765869317,\n",
       "  0.0003223409714672165,\n",
       "  0.049991991057513285])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# logistic regression test for the fair representation of data (barycenter pair)\n",
    "LRModelsAUC=[]\n",
    "LRTestPreds=[]\n",
    "test_disc = []\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    lr=LogisticRegression()\n",
    "    lr.fit(X_TrainFairList[i],Y_TrainFairList[i])\n",
    "    proba=lr.predict_proba(X_TestFairList[i])\n",
    "    ytrue=TestList[i][Y_features]\n",
    "    testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "    LRModelsAUC.append(testauc)\n",
    "    temp=TestList[i][Z_features+X_features+Y_features]\n",
    "    temp['pred']=proba[:,1]\n",
    "    mean = temp.groupby(Z_features)['pred'].mean()\n",
    "    v = mean.values\n",
    "    v = v.reshape(len(v),1)\n",
    "    ratio_df = pd.DataFrame(v/v.transpose(),index=mean.index,columns=mean.index )\n",
    "    ratio_df_arr=np.asarray(np.abs(1-ratio_df))\n",
    "    maxdisc=np.amax(ratio_df_arr)\n",
    "    test_disc.append(maxdisc)   \n",
    "\n",
    "LRres_Pseudobary = (LRModelsAUC, LRTestPreds)\n",
    "LRDisc_Pseudobary = test_disc\n",
    "    \n",
    "    \n",
    "LRModelsAUC, LRDisc_Pseudobary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimate the geodesic path from the E(Y|X_z) to the barycenter of the marginal conditional expectations\n",
    "1. Compute both geodesic path path from X to X^dash and from Y to Y^dash\n",
    "2. Use diagonal argument to estimate the geodesic path from the original E(Y|X) to E(Y^dash|X^dash) on both train and test data sets: X_train/test_path_list, Y_train\\test_path_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-6-1452a291d234>:19: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  tempt_train[gender_train_i == 1,:] = (1-T[t])*train[gender_train_i == 1,:] + T[t]*((train[gender_train_i == 1,:] - X_A_mean) @ T_X_A.T + X_mean)\n",
      "<ipython-input-6-1452a291d234>:20: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  tempt_train[gender_train_i == 0,:] = (1-T[t])*train[gender_train_i == 0,:] + T[t]*((train[gender_train_i == 0,:] - X_C_mean) @ T_X_C.T + X_mean)\n",
      "<ipython-input-6-1452a291d234>:21: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  tempt_test[gender_test_i == 1,:] = (1-T[t])*test[gender_test_i == 1,:] + T[t]*((test[gender_test_i == 1,:] - X_A_mean) @ T_X_A.T + X_mean)\n",
      "<ipython-input-6-1452a291d234>:22: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  tempt_test[gender_test_i == 0,:] = (1-T[t])*test[gender_test_i == 0,:] + T[t]*((test[gender_test_i == 0,:] - X_C_mean) @ T_X_C.T + X_mean)\n"
     ]
    }
   ],
   "source": [
    "# Algorithm 1, step 3: estimate of the independent variable (X) geodesic path using McCann interpolation\n",
    "X_train_path_list = []\n",
    "X_test_path_list = []\n",
    "T = np.linspace(0,1,50) # discretize time variable T\n",
    "Id = np.identity(7)\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    X_train_path = []\n",
    "    X_test_path = []\n",
    "    train = np.delete(np.array(pd.get_dummies(TrainList[i][X_features])),[4],axis = 1)\n",
    "    test = np.delete(np.array(pd.get_dummies(TestList[i][X_features])),[4],axis = 1)\n",
    "    gender_train_i = np.delete(np.array(pd.get_dummies(TrainList[i][Z_features])),[1],axis = 1).T[0,:]\n",
    "    gender_test_i = np.delete(np.array(pd.get_dummies(TestList[i][Z_features])),[1],axis = 1).T[0,:]\n",
    "    for t in range(0,len(T)):\n",
    "        train_new = np.random.rand(train.shape[0],train.shape[1])\n",
    "        test_new = np.random.rand(test.shape[0],test.shape[1])\n",
    "        tempt_train = train_new\n",
    "        tempt_test = test_new\n",
    "        tempt_train[gender_train_i == 1,:] = (1-T[t])*train[gender_train_i == 1,:] + T[t]*((train[gender_train_i == 1,:] - X_A_mean) @ T_X_A.T + X_mean)\n",
    "        tempt_train[gender_train_i == 0,:] = (1-T[t])*train[gender_train_i == 0,:] + T[t]*((train[gender_train_i == 0,:] - X_C_mean) @ T_X_C.T + X_mean)\n",
    "        tempt_test[gender_test_i == 1,:] = (1-T[t])*test[gender_test_i == 1,:] + T[t]*((test[gender_test_i == 1,:] - X_A_mean) @ T_X_A.T + X_mean)\n",
    "        tempt_test[gender_test_i == 0,:] = (1-T[t])*test[gender_test_i == 0,:] + T[t]*((test[gender_test_i == 0,:] - X_C_mean) @ T_X_C.T + X_mean)\n",
    "        # Algorithm 1, step 4: merge the corresponding (wrt t) linear interpolation of sensitive variable back to the MacCann interpolation of dependnet variable\n",
    "        X_train_path.append(np.concatenate((tempt_train, np.expand_dims(gender_train_i*(1-T[t]), axis=1)),axis = 1))\n",
    "        X_test_path.append(np.concatenate((tempt_test, np.expand_dims(gender_test_i*(1-T[t]), axis=1)),axis = 1))\n",
    "    X_train_path_list.append(X_train_path)\n",
    "    X_test_path_list.append(X_test_path)\n",
    "    \n",
    "# Algorithm 2, step 3: estimate of the dependnet (Y) geodesic path using McCann interpolation\n",
    "Y_train_path_list = []\n",
    "Y_test_path_list = []\n",
    "T = np.linspace(0,1,50)\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    Y_train_path = []\n",
    "    Y_test_path = []\n",
    "    train = np.array(pd.get_dummies(TrainList[i][Y_features]))\n",
    "    test = np.array(pd.get_dummies(TestList[i][Y_features]))\n",
    "    gender_train_i = np.array(TrainList[i][Z_features]).T[0,:]\n",
    "    gender_test_i = np.array(TestList[i][Z_features]).T[0,:]\n",
    "    for t in range(0,len(T)):\n",
    "        train_new = np.random.rand(len(train.T[0,:]))\n",
    "        test_new = np.random.rand(len(test.T[0,:]))\n",
    "        tempt_train = train_new\n",
    "        tempt_test = test_new\n",
    "        tempt_train[gender_train_i == 'African-American'] = ((1 - T[t] + T[t]*T_Y_A)*train[gender_train_i == 'African-American'] + T[t]*(Y_mean - T_Y_A*Y_A_mean)).T[0,:]\n",
    "        tempt_train[gender_train_i == 'Caucasian'] = ((1 - T[t] + T[t]*T_Y_C)*train[gender_train_i == 'Caucasian'] + T[t]*(Y_mean - T_Y_C*Y_C_mean)).T[0,:]\n",
    "        tempt_test[gender_test_i == 'African-American'] = ((1 - T[t] + T[t]*T_Y_A)*test[gender_test_i == 'African-American'] + T[t]*(Y_mean - T_Y_A*Y_A_mean)).T[0,:]\n",
    "        tempt_test[gender_test_i == 'Caucasian'] = ((1 - T[t] + T[t]*T_Y_C)*test[gender_test_i == 'Caucasian'] + T[t]*(Y_mean - T_Y_C*Y_C_mean)).T[0,:]\n",
    "        Y_train_path.append(tempt_train)\n",
    "        Y_test_path.append(tempt_test)\n",
    "    Y_train_path_list.append(Y_train_path)\n",
    "    Y_test_path_list.append(Y_test_path)\n",
    "\n",
    "# Algorithm 2, step 4: reshape the dependent pseudo-barycenter to binary variable for logit regression\n",
    "for t in range(0,len(T)):\n",
    "    for i in range(0,len(TrainList)):\n",
    "        fair_value = np.unique(Y_train_path_list[i][t])\n",
    "        Y_prob = (fair_value - np.min(fair_value))/(np.max(fair_value) - np.min(fair_value))\n",
    "        for j in range(0,len(fair_value)):\n",
    "            Y_train_path_list[i][t][Y_train_path_list[i][t] == fair_value[j]] = np.random.binomial(size = len(np.where(Y_train_path_list[i][t] == fair_value[j])[0]),n = 1,p = Y_prob[j])\n",
    "            Y_test_path_list[i][t][Y_test_path_list[i][t] == fair_value[j]] = np.random.binomial(size = len(np.where(Y_test_path_list[i][t] == fair_value[j])[0]),n = 1,p = Y_prob[j])\n",
    "            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance Tests and Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ROC AUC of random forest trained via the fair data representation interpolation: RFModelsAUC_path_list\n",
    "RFModelsAUC_path_list =[]\n",
    "# classification discrimination (definition 6.1) of standard random forest trained via the fair data representation interpolation: RFDisc_path_list\n",
    "RFDisc_path_list =[]\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    ModelsAUC_path = []\n",
    "    test_disc_path=[]\n",
    "    for t in range(0,len(T)):\n",
    "        rf=RandomForestClassifier()\n",
    "        rf.fit(X_train_path_list[i][t],Y_train_path_list[i][t])\n",
    "        proba=rf.predict_proba(X_test_path_list[i][t])\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        ModelsAUC_path.append(testauc)\n",
    "        temp=TestList[i][Z_features+X_features+Y_features]\n",
    "        temp['pred']=proba[:,1]\n",
    "        mean = temp.groupby(Z_features)['pred'].mean()\n",
    "        v = mean.values\n",
    "        v = v.reshape(len(v),1)\n",
    "        ratio_df = pd.DataFrame(v/v.transpose(),index=mean.index,columns=mean.index )\n",
    "        ratio_df_arr=np.asarray(np.abs(1-ratio_df))\n",
    "        maxdisc=np.amax(ratio_df_arr)   \n",
    "        test_disc_path.append(maxdisc)\n",
    "    \n",
    "    RFModelsAUC_path_list.append(ModelsAUC_path)\n",
    "    RFDisc_path_list.append(test_disc_path)\n",
    "\n",
    "# ROC AUC of logistic regression trained via the fair data representation interpolation: LRModelsAUC_path_list\n",
    "LRModelsAUC_path_list =[]\n",
    "# classification discrimination (definition 6.1) of logistic regression trained via the fair data representation interpolation: LRDisc_path_list\n",
    "LRDisc_path_list =[]\n",
    "\n",
    "for i in range(0,len(TrainList)):\n",
    "    ModelsAUC_path = []\n",
    "    test_disc_path=[]\n",
    "    for t in range(0,len(T)):\n",
    "        lr=LogisticRegression()\n",
    "        lr.fit(X_train_path_list[i][t],Y_train_path_list[i][t])\n",
    "        proba=lr.predict_proba(X_test_path_list[i][t])\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        ModelsAUC_path.append(testauc)\n",
    "        temp=TestList[i][Z_features+X_features+Y_features]\n",
    "        temp['pred']=proba[:,1]\n",
    "        mean = temp.groupby(Z_features)['pred'].mean()\n",
    "        v = mean.values\n",
    "        v = v.reshape(len(v),1)\n",
    "        ratio_df = pd.DataFrame(v/v.transpose(),index=mean.index,columns=mean.index )\n",
    "        ratio_df_arr=np.asarray(np.abs(1-ratio_df))\n",
    "        maxdisc=np.amax(ratio_df_arr)   \n",
    "        test_disc_path.append(maxdisc)\n",
    "    \n",
    "    LRModelsAUC_path_list.append(ModelsAUC_path)\n",
    "    LRDisc_path_list.append(test_disc_path)\n",
    "\n",
    "# average auc and discrimination of the five fold cross validation: acc_RF, dis_RF, acc_LR, dis_LR\n",
    "acc_RF = np.average(np.array(RFModelsAUC_path_list),axis = 0)\n",
    "dis_RF = np.average(np.array(RFDisc_path_list),axis = 0)\n",
    "acc_LR = np.average(np.array(LRModelsAUC_path_list),axis = 0)\n",
    "dis_LR = np.average(np.array(LRDisc_path_list),axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.36861616, 0.35964505, 0.35096968, 0.34254763, 0.33448963,\n",
       "        0.32498241, 0.31135402, 0.30955112, 0.29941488, 0.29778921,\n",
       "        0.28309597, 0.27916349, 0.26644829, 0.26505904, 0.2507414 ,\n",
       "        0.24931576, 0.23310671, 0.22058987, 0.21994836, 0.21641123,\n",
       "        0.20486478, 0.19517995, 0.19834731, 0.18770387, 0.17818897,\n",
       "        0.16221893, 0.16227297, 0.16014145, 0.15380935, 0.14625536,\n",
       "        0.13502905, 0.12907829, 0.11511706, 0.11739692, 0.09701072,\n",
       "        0.10570766, 0.09425691, 0.09408618, 0.07882182, 0.0662637 ,\n",
       "        0.08624998, 0.06736881, 0.05745256, 0.04701713, 0.0423854 ,\n",
       "        0.03739774, 0.03094599, 0.0276594 , 0.01971673, 0.01810813]),\n",
       " array([0.70521774, 0.70563748, 0.70540247, 0.70472485, 0.70544214,\n",
       "        0.70512002, 0.70511106, 0.70507579, 0.70549007, 0.70445314,\n",
       "        0.70473575, 0.70513976, 0.70499374, 0.70478837, 0.70383084,\n",
       "        0.70343838, 0.70325118, 0.70272983, 0.70285121, 0.70140605,\n",
       "        0.7025143 , 0.70268848, 0.70168806, 0.70108255, 0.70092393,\n",
       "        0.70176504, 0.69995932, 0.70158649, 0.70156555, 0.69952003,\n",
       "        0.69977804, 0.70121517, 0.70036396, 0.70047352, 0.69902854,\n",
       "        0.69867467, 0.69846225, 0.69976628, 0.69961919, 0.69918917,\n",
       "        0.69751603, 0.69893909, 0.69933109, 0.69685728, 0.6975087 ,\n",
       "        0.69728795, 0.69579354, 0.69523631, 0.69522441, 0.692493  ]),\n",
       " array([0.364938  , 0.35904911, 0.34983282, 0.34107281, 0.32962713,\n",
       "        0.32457401, 0.3075073 , 0.30964365, 0.30016356, 0.2906106 ,\n",
       "        0.27858862, 0.2779613 , 0.26525053, 0.26170322, 0.24789979,\n",
       "        0.24529828, 0.22844085, 0.22153893, 0.21989579, 0.21667638,\n",
       "        0.20165147, 0.19524737, 0.1962055 , 0.18620742, 0.17738006,\n",
       "        0.16274795, 0.1622607 , 0.15846923, 0.155556  , 0.14574934,\n",
       "        0.13242429, 0.13120295, 0.11199034, 0.11676503, 0.09393006,\n",
       "        0.1038516 , 0.0959571 , 0.09772855, 0.08025844, 0.06577492,\n",
       "        0.09268161, 0.07188817, 0.05789984, 0.04247862, 0.04512593,\n",
       "        0.04110399, 0.0355634 , 0.03869149, 0.02379325, 0.02485373]),\n",
       " array([0.70155118, 0.70097774, 0.69918806, 0.70080056, 0.70138432,\n",
       "        0.70159496, 0.69933429, 0.70003683, 0.70137996, 0.69735703,\n",
       "        0.69899103, 0.69970209, 0.7010493 , 0.69969081, 0.69955633,\n",
       "        0.6978424 , 0.69629474, 0.69951801, 0.69736097, 0.69816208,\n",
       "        0.69878969, 0.69646621, 0.69754434, 0.69866649, 0.69665265,\n",
       "        0.69778387, 0.69475408, 0.69841872, 0.69690044, 0.69508326,\n",
       "        0.69850039, 0.69761724, 0.69614388, 0.69422303, 0.69432551,\n",
       "        0.6932267 , 0.69360198, 0.69773638, 0.69766143, 0.69495386,\n",
       "        0.69302765, 0.69275396, 0.69262788, 0.68920215, 0.69177558,\n",
       "        0.69253032, 0.69060388, 0.69154618, 0.68930261, 0.6908493 ]))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dis_LR, acc_LR, dis_RF, acc_RF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Methods and Corresponding Numerical Implements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "interploation_model = interp1d(dis_RF, acc_RF, kind = \"linear\")\n",
    " \n",
    "# Plotting the Graph\n",
    "X_RF=np.linspace(dis_RF.min(), dis_RF.max(), 500)\n",
    "Y_RF=interploation_model(X_RF)\n",
    " \n",
    "plt.plot(X_RF, Y_RF)\n",
    "plt.title(\"Pareto Frontier for Random Forest on COMPAS\")\n",
    "plt.xlabel(\"Disparity\")\n",
    "plt.ylabel(\"AUC\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "interploation_model = interp1d(dis_LR, acc_LR, kind = \"linear\")\n",
    " \n",
    "# Plotting the Graph\n",
    "X_LR=np.linspace(dis_LR.min(), dis_LR.max(), 500)\n",
    "Y_LR=interploation_model(X_LR)\n",
    " \n",
    "plt.plot(X_LR, Y_LR)\n",
    "plt.title(\"Pareto Frontier for Logistic Regression on COMPAS\")\n",
    "plt.xlabel(\"Disparity\")\n",
    "plt.ylabel(\"AUC\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the trained logisctic regression model in the paper by Calmon\n",
    "def RunLRClassifier(TrainList,TestList,TrainNewList,TestNewList,Z_features,X_features,Y_features):\n",
    "    LRModelsAUC=[]\n",
    "    LRTestPreds=[]\n",
    "    for i in range(0,len(TrainNewList)):\n",
    "        dft = pd.get_dummies(TrainNewList[i][Z_features+X_features])\n",
    "        lr=LogisticRegression()\n",
    "        lr.fit(dft,TrainNewList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestNewList[i][Z_features+X_features])\n",
    "        proba=lr.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        LRModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        LRTestPreds.append(dft)\n",
    "    return LRModelsAUC,LRTestPreds\n",
    "\n",
    "# define the logistic regression model without using the sensitive information\n",
    "def RunLRWithoutDClassifier(TrainList,TestList,Z_features,X_features,Y_features):\n",
    "    LRModelsAUC=[]\n",
    "    LRTestPreds=[]\n",
    "    for i in range(0,len(TrainList)): \n",
    "        dft = pd.get_dummies(TrainList[i][X_features])\n",
    "        lr=LogisticRegression()\n",
    "        lr.fit(dft,TrainList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestList[i][X_features])\n",
    "        proba=lr.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        LRModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        LRTestPreds.append(dft)\n",
    "    return LRModelsAUC,LRTestPreds\n",
    "\n",
    "# define the standard logistic regression model\n",
    "def RunPlainLRClassifier(TrainList,TestList,Z_features,X_features,Y_features):\n",
    "    LRModelsAUC=[]\n",
    "    LRTestPreds=[]\n",
    "    for i in range(0,len(TrainList)): \n",
    "        dft = pd.get_dummies(TrainList[i][Z_features+X_features])\n",
    "        lr=LogisticRegression()\n",
    "        lr.fit(dft,TrainList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestList[i][Z_features+X_features])\n",
    "        proba=lr.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        LRModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        LRTestPreds.append(dft)\n",
    "    return LRModelsAUC,LRTestPreds\n",
    "\n",
    "# define the trained random forest model in the paper by Calmon\n",
    "def RunRFClassifier(TrainList,TestList,TrainNewList,TestNewList,Z_features,X_features,Y_features):\n",
    "    RFModelsAUC=[]\n",
    "    RFTestPreds=[]\n",
    "    for i in range(0,len(TrainNewList)):\n",
    "        dft = pd.get_dummies(TrainNewList[i][Z_features+X_features])\n",
    "        rf=RandomForestClassifier()\n",
    "        rf.fit(dft,TrainNewList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestNewList[i][Z_features+X_features])\n",
    "        proba=rf.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        RFModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        RFTestPreds.append(dft)\n",
    "    return RFModelsAUC,RFTestPreds\n",
    "\n",
    "# define the random forest model without using the sensitive information\n",
    "def RunRFWithoutDClassifier(TrainList,TestList,Z_features,X_features,Y_features):\n",
    "    RFModelsAUC=[]\n",
    "    RFTestPreds=[]\n",
    "    for i in range(0,len(TrainList)): \n",
    "        dft = pd.get_dummies(TrainList[i][X_features])\n",
    "        rf=RandomForestClassifier()\n",
    "        rf.fit(dft,TrainList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestList[i][X_features])\n",
    "        proba=rf.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        RFModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        RFTestPreds.append(dft)\n",
    "    return RFModelsAUC,RFTestPreds\n",
    "\n",
    "# define the standard random forest model\n",
    "def RunPlainRFClassifier(TrainList,TestList,Z_features,X_features,Y_features):\n",
    "    RFModelsAUC=[]\n",
    "    RFTestPreds=[]\n",
    "    for i in range(0,len(TrainList)): \n",
    "        dft = pd.get_dummies(TrainList[i][Z_features+X_features])\n",
    "        rf=RandomForestClassifier()\n",
    "        rf.fit(dft,TrainList[i][Y_features])\n",
    "        dft = pd.get_dummies(TestList[i][Z_features+X_features])\n",
    "        proba=rf.predict_proba(dft)\n",
    "        ytrue=TestList[i][Y_features]\n",
    "        testauc=roc_auc_score(ytrue, proba[:, 1])\n",
    "        RFModelsAUC.append(testauc)\n",
    "        dft=TestList[i][Z_features+X_features+Y_features]\n",
    "        dft['pred']=proba[:,1]\n",
    "        RFTestPreds.append(dft)\n",
    "    return RFModelsAUC,RFTestPreds\n",
    "\n",
    "# compute the discrimition\n",
    "def ComputeDiscrimination(LRTestPreds,Z_features):\n",
    "    test_disc=[]\n",
    "    for i in range(0,len(LRTestPreds)):\n",
    "        mean = LRTestPreds[i].groupby(Z_features)['pred'].mean()\n",
    "        v = mean.values\n",
    "        v = v.reshape(len(v),1)\n",
    "        ratio_df = pd.DataFrame(v/v.transpose(),index=mean.index,columns=mean.index )\n",
    "        ratio_df_arr=np.asarray(np.abs(1-ratio_df))\n",
    "        maxdisc=np.amax(ratio_df_arr)\n",
    "        test_disc.append(maxdisc)   \n",
    "    return test_disc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-11-8cb1aa841593>:62: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainNewList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:62: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainNewList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:62: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainNewList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:62: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainNewList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:62: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainNewList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:98: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:98: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:98: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:98: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:98: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:80: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:80: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:80: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:80: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "<ipython-input-11-8cb1aa841593>:80: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  rf.fit(dft,TrainList[i][Y_features])\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n",
      "/opt/anaconda3/lib/python3.8/site-packages/sklearn/utils/validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Comparison Experiment\n",
    "RFres_RFClassifier=RunRFClassifier(TrainList,TestList,TrainNewList,TestNewList,Z_features,X_features,Y_features)\n",
    "RFres_PlainRFClassifier=RunPlainRFClassifier(TrainList,TestList,Z_features,X_features,Y_features)\n",
    "RFres_RFWithoutDClassifier=RunRFWithoutDClassifier(TrainList,TestList,Z_features,X_features,Y_features)\n",
    "RFDisc_RFClassifier=ComputeDiscrimination(RFres_RFClassifier[1],Z_features)\n",
    "RFDisc_PlainRFClassifier=ComputeDiscrimination(RFres_PlainRFClassifier[1],Z_features)\n",
    "RFDisc_RFWithoutDClassifier=ComputeDiscrimination(RFres_RFWithoutDClassifier[1],Z_features)\n",
    "\n",
    "from scipy.stats import t\n",
    "RFAUC1=np.asarray(RFres_RFClassifier[0])\n",
    "RFAUC2=np.asarray(RFres_PlainRFClassifier[0])\n",
    "RFAUC3=np.asarray(RFres_RFWithoutDClassifier[0])\n",
    "RFAUC4=np.asarray(np.array(RFModelsAUC_path_list)[:,49])\n",
    "RF_mean1 = np.mean(RFAUC1)\n",
    "RF_mean2 = np.mean(RFAUC2)\n",
    "RF_mean3 = np.mean(RFAUC3)\n",
    "RF_mean4 = np.mean(RFAUC4)\n",
    "\n",
    "zemelauc=np.asarray([0.676842373423,0.693,0.687,0.693,0.699])\n",
    "#zemelauc=np.asarray([0.706,0.682,0.701,0.705,0.706])\n",
    "zemel_mean=np.mean(zemelauc)\n",
    "\n",
    "# standard deviation\n",
    "RF_std1 = np.std(RFAUC1)\n",
    "RF_std2 = np.std(RFAUC2)\n",
    "RF_std3 = np.std(RFAUC3)\n",
    "RF_std4 = np.std(RFAUC4)\n",
    "zemel_std=np.std(zemelauc)\n",
    "\n",
    "RFDisc1=np.asarray(RFDisc_RFClassifier)\n",
    "RFDisc2=np.asarray(RFDisc_PlainRFClassifier)\n",
    "RFDisc3=np.asarray(RFDisc_RFWithoutDClassifier)\n",
    "RFDisc4=np.asarray(np.array(RFDisc_path_list)[:,49])\n",
    "RFdisc_mean1 = np.mean(RFDisc1)\n",
    "RFdisc_mean2 = np.mean(RFDisc2)\n",
    "RFdisc_mean3 = np.mean(RFDisc3)\n",
    "RFdisc_mean4 = np.mean(RFDisc4)\n",
    "RFdisc_std1=np.std(RFDisc1)\n",
    "RFdisc_std2=np.std(RFDisc2)\n",
    "RFdisc_std3=np.std(RFDisc3)\n",
    "RFdisc_std4=np.std(RFDisc4)\n",
    "\n",
    "zemel_disc=np.asarray([0.0197,0.0122,0.0149,0.046])\n",
    "#zemel_disc=np.asarray([0.265,0.375,0.284,0.303,0.330])\n",
    "zemel_disc_mean=np.mean(zemel_disc)\n",
    "zemel_disc_std=np.std(zemel_disc)\n",
    "\n",
    "# Logistic Regression Comparison Experiment\n",
    "LRres_LRClassifier=RunLRClassifier(TrainList,TestList,TrainNewList,TestNewList,Z_features,X_features,Y_features)\n",
    "LRres_PlainLRClassifier=RunPlainLRClassifier(TrainList,TestList,Z_features,X_features,Y_features)\n",
    "LRres_LRWithoutDClassifier=RunLRWithoutDClassifier(TrainList,TestList,Z_features,X_features,Y_features)\n",
    "LRDisc_LRClassifier=ComputeDiscrimination(LRres_LRClassifier[1],Z_features)\n",
    "LRDisc_PlainLRClassifier=ComputeDiscrimination(LRres_PlainLRClassifier[1],Z_features)\n",
    "LRDisc_LRWithoutDClassifier=ComputeDiscrimination(LRres_LRWithoutDClassifier[1],Z_features)\n",
    "\n",
    "from scipy.stats import t\n",
    "LRAUC1=np.asarray(LRres_LRClassifier[0])\n",
    "LRAUC2=np.asarray(LRres_PlainLRClassifier[0])\n",
    "LRAUC3=np.asarray(LRres_LRWithoutDClassifier[0])\n",
    "LRAUC4=np.asarray(np.array(LRModelsAUC_path_list)[:,49])\n",
    "LR_mean1 = np.mean(LRAUC1)\n",
    "LR_mean2 = np.mean(LRAUC2)\n",
    "LR_mean3 = np.mean(LRAUC3)\n",
    "LR_mean4 = np.mean(LRAUC4)\n",
    "\n",
    "zemelauc=np.asarray([0.676842373423,0.693,0.687,0.693,0.699])\n",
    "zemel_mean=np.mean(zemelauc)\n",
    "\n",
    "# standard deviation\n",
    "LR_std1 = np.std(LRAUC1)\n",
    "LR_std2 = np.std(LRAUC2)\n",
    "LR_std3 = np.std(LRAUC3)\n",
    "LR_std4 = np.std(LRAUC4)\n",
    "zemel_std=np.std(zemelauc)\n",
    "\n",
    "LRDisc1=np.asarray(LRDisc_LRClassifier)\n",
    "LRDisc2=np.asarray(LRDisc_PlainLRClassifier)\n",
    "LRDisc3=np.asarray(LRDisc_LRWithoutDClassifier)\n",
    "LRDisc4=np.asarray(np.array(LRDisc_path_list)[:,49])\n",
    "LRdisc_mean1 = np.mean(LRDisc1)\n",
    "LRdisc_mean2 = np.mean(LRDisc2)\n",
    "LRdisc_mean3 = np.mean(LRDisc3)\n",
    "LRdisc_mean4 = np.mean(LRDisc4)\n",
    "LRdisc_std1=np.std(LRDisc1)\n",
    "LRdisc_std2=np.std(LRDisc2)\n",
    "LRdisc_std3=np.std(LRDisc3)\n",
    "LRdisc_std4=np.std(LRDisc4)\n",
    "\n",
    "zemel_disc=np.asarray([0.0197,0.0122,0.0149,0.046])\n",
    "zemel_disc_mean=np.mean(zemel_disc)\n",
    "zemel_disc_std=np.std(zemel_disc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 2, figsize=(15,5))\n",
    "\n",
    "axs[0].errorbar(LRdisc_mean2, LR_mean2, xerr=LRdisc_std2, yerr=LR_std2, fmt='-o') # LR\n",
    "axs[0].errorbar(LRdisc_mean3, LR_mean3, xerr=LRdisc_std3, yerr=LR_std3, fmt='-o') # LR + Excluding Z\n",
    "axs[0].errorbar(zemel_disc_mean, zemel_mean, xerr=zemel_disc_std, yerr=zemel_std, fmt='-o') # LR + Zemel\n",
    "axs[0].errorbar(LRdisc_mean1, LR_mean1, xerr=LRdisc_std1, yerr=LR_std1, fmt='-o',color = '#9467bd') # LR + Calmon(0.05)\n",
    "axs[0].errorbar(LRdisc_mean4, LR_mean4, xerr=LRdisc_std4, yerr=LR_std4, fmt='-o',color = '#d62728') # LR + pseudo-barycenter\n",
    "axs[0].plot(X_LR, Y_LR, linewidth = 2, color = '#d62728') # LR Pareto Frontier Estimation\n",
    "\n",
    "\n",
    "\n",
    "axs[0].tick_params(axis=\"both\", which=\"both\", bottom=\"off\", top=\"off\",  \n",
    "                labelbottom=\"on\", left=\"on\", right=\"off\", labelleft=\"on\")  \n",
    "\n",
    "axs[0].legend(['LR Pareto Frontier Est','LR','LR + Excluding Z','LR + Zemel','LR + Calmon(.05)','LR + Pseudo-barycenter'], \n",
    "           loc='best',fancybox=True)\n",
    "\n",
    "axs[0].set_ylabel('AUC', fontsize=14)\n",
    "axs[0].set_xlabel('Discrimination', fontsize=14)\n",
    "axs[0].set_title(f\"Logistic Regression Comparison on COMPAS\", fontsize=15)\n",
    "axs[0].set_ylim(0.62, 0.72)\n",
    "axs[0].set_xlim(-0.1, 0.5)\n",
    "\n",
    "\n",
    "axs[1].errorbar(RFdisc_mean2, RF_mean2, xerr=RFdisc_std2, yerr=RF_std2, fmt='-o') # RF\n",
    "axs[1].errorbar(RFdisc_mean3, RF_mean3, xerr=RFdisc_std3, yerr=RF_std3, fmt='-o') # RF + Excluding Z\n",
    "axs[1].errorbar(zemel_disc_mean, zemel_mean, xerr=zemel_disc_std, yerr=zemel_std, fmt='-o') # LR + Zemel\n",
    "axs[1].errorbar(RFdisc_mean1, RF_mean1, xerr=RFdisc_std1, yerr=RF_std1, fmt='-o',color = '#9467bd') # RF + Calmon(0.05)\n",
    "axs[1].errorbar(RFdisc_mean4, RF_mean4, xerr=RFdisc_std4, yerr=RF_std4, fmt='-o',color = '#d62728') # RF + pseudo-barycenter\n",
    "axs[1].plot(X_RF, Y_RF, linewidth = 2, color = '#d62728') # LR Pareto Frontier Estimation\n",
    "\n",
    "\n",
    "\n",
    "#fig.axes.get_xaxis().set_visible(False)\n",
    "\n",
    "axs[1].tick_params(axis=\"both\", which=\"both\", bottom=\"off\", top=\"off\",  \n",
    "                labelbottom=\"on\", left=\"on\", right=\"off\", labelleft=\"on\")  \n",
    "\n",
    "axs[1].legend(['RF Pareto Fronteir Est','RF','RF + Excluding Z','RF + Zemel','RF + Calmon(.05)','RF + Pseudo-barycenter'], \n",
    "           loc='best',fancybox=True)\n",
    "\n",
    "axs[1].set_ylabel('AUC', fontsize=14)\n",
    "axs[1].set_xlabel('Discrimination', fontsize=14)\n",
    "axs[1].set_title(f\"Random Forest Comparison on COMPAS\", fontsize=15)\n",
    "axs[1].set_ylim(0.62, 0.72)\n",
    "axs[1].set_xlim(-0.1, 0.5)\n",
    "\n",
    "fig.subplots_adjust(wspace=0.2,hspace=0.2)\n",
    "plt.savefig('Pareto Frontier COMPAS', dpi=400,bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}