examples/demo_calibrated_eqodds_postprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### This notebook demonstrates the use of an odds-equalizing post-processing algorithm for bias mitigiation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# Load all necessary packages\n",
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "sys.path.append(\"../\")\n",
    "from aif360.datasets import AdultDataset, GermanDataset, CompasDataset\n",
    "from aif360.metrics import BinaryLabelDatasetMetric\n",
    "from aif360.metrics import ClassificationMetric\n",
    "from aif360.metrics.utils import compute_boolean_conditioning_vector\n",
    "\n",
    "from aif360.algorithms.preprocessing.optim_preproc_helpers.data_preproc_functions\\\n",
    "                import load_preproc_data_adult, load_preproc_data_compas\n",
    "\n",
    "from sklearn.preprocessing import scale\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "from IPython.display import Markdown, display\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fairness metrics for original dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Missing Data: 3620 rows removed from AdultDataset.\n"
     ]
    }
   ],
   "source": [
    "## import dataset\n",
    "dataset_used = \"adult\" # \"adult\", \"german\", \"compas\"\n",
    "protected_attribute_used = 1 # 1, 2\n",
    "\n",
    "if dataset_used == \"adult\":\n",
    "    dataset_orig = AdultDataset()\n",
    "#     dataset_orig = load_preproc_data_adult()\n",
    "    if protected_attribute_used == 1:\n",
    "        privileged_groups = [{'sex': 1}]\n",
    "        unprivileged_groups = [{'sex': 0}]\n",
    "    else:\n",
    "        privileged_groups = [{'race': 1}]\n",
    "        unprivileged_groups = [{'race': 0}]\n",
    "    \n",
    "elif dataset_used == \"german\":\n",
    "    dataset_orig = GermanDataset()\n",
    "    if protected_attribute_used == 1:\n",
    "        privileged_groups = [{'sex': 1}]\n",
    "        unprivileged_groups = [{'sex': 0}]\n",
    "    else:\n",
    "        privileged_groups = [{'age': 1}]\n",
    "        unprivileged_groups = [{'age': 0}]\n",
    "    \n",
    "elif dataset_used == \"compas\":\n",
    "#     dataset_orig = CompasDataset()\n",
    "    dataset_orig = load_preproc_data_compas()\n",
    "    if protected_attribute_used == 1:\n",
    "        privileged_groups = [{'sex': 1}]\n",
    "        unprivileged_groups = [{'sex': 0}]\n",
    "    else:\n",
    "        privileged_groups = [{'race': 1}]\n",
    "        unprivileged_groups = [{'race': 0}]    \n",
    "\n",
    "# cost constraint of fnr will optimize generalized false negative rates, that of\n",
    "# fpr will optimize generalized false positive rates, and weighted will optimize\n",
    "# a weighted combination of both\n",
    "cost_constraint = \"fnr\" # \"fnr\", \"fpr\", \"weighted\"\n",
    "#random seed for calibrated equal odds prediction\n",
    "randseed = 12345679 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Divide dataset into train, validation, and test partitions (70-30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_orig_train, dataset_orig_vt = dataset_orig.split([0.6], shuffle=True)\n",
    "dataset_orig_valid, dataset_orig_test = dataset_orig_vt.split([0.5], shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training data characteristics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Dataset shape"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(27133, 98)\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Favorable and unfavorable labels"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.0, 0.0)\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Protected attribute names"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['race', 'sex']\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Privileged and unprivileged protected attribute values"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([array([1.]), array([1.])], [array([0.]), array([0.])])\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Dataset feature names"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['age', 'capital-gain', 'sex', 'hours-per-week', 'race', 'education-num', 'capital-loss', 'workclass=Federal-gov', 'workclass=Local-gov', 'workclass=Private', 'workclass=Self-emp-inc', 'workclass=Self-emp-not-inc', 'workclass=State-gov', 'workclass=Without-pay', 'education=10th', 'education=11th', 'education=12th', 'education=1st-4th', 'education=5th-6th', 'education=7th-8th', 'education=9th', 'education=Assoc-acdm', 'education=Assoc-voc', 'education=Bachelors', 'education=Doctorate', 'education=HS-grad', 'education=Masters', 'education=Preschool', 'education=Prof-school', 'education=Some-college', 'marital-status=Divorced', 'marital-status=Married-AF-spouse', 'marital-status=Married-civ-spouse', 'marital-status=Married-spouse-absent', 'marital-status=Never-married', 'marital-status=Separated', 'marital-status=Widowed', 'occupation=Adm-clerical', 'occupation=Armed-Forces', 'occupation=Craft-repair', 'occupation=Exec-managerial', 'occupation=Farming-fishing', 'occupation=Handlers-cleaners', 'occupation=Machine-op-inspct', 'occupation=Other-service', 'occupation=Priv-house-serv', 'occupation=Prof-specialty', 'occupation=Protective-serv', 'occupation=Sales', 'occupation=Tech-support', 'occupation=Transport-moving', 'relationship=Husband', 'relationship=Not-in-family', 'relationship=Other-relative', 'relationship=Own-child', 'relationship=Unmarried', 'relationship=Wife', 'native-country=Cambodia', 'native-country=Canada', 'native-country=China', 'native-country=Columbia', 'native-country=Cuba', 'native-country=Dominican-Republic', 'native-country=Ecuador', 'native-country=El-Salvador', 'native-country=England', 'native-country=France', 'native-country=Germany', 'native-country=Greece', 'native-country=Guatemala', 'native-country=Haiti', 'native-country=Holand-Netherlands', 'native-country=Honduras', 'native-country=Hong', 'native-country=Hungary', 'native-country=India', 'native-country=Iran', 'native-country=Ireland', 'native-country=Italy', 'native-country=Jamaica', 'native-country=Japan', 'native-country=Laos', 'native-country=Mexico', 'native-country=Nicaragua', 'native-country=Outlying-US(Guam-USVI-etc)', 'native-country=Peru', 'native-country=Philippines', 'native-country=Poland', 'native-country=Portugal', 'native-country=Puerto-Rico', 'native-country=Scotland', 'native-country=South', 'native-country=Taiwan', 'native-country=Thailand', 'native-country=Trinadad&Tobago', 'native-country=United-States', 'native-country=Vietnam', 'native-country=Yugoslavia']\n"
     ]
    }
   ],
   "source": [
    "# print out some labels, names, etc.\n",
    "display(Markdown(\"#### Dataset shape\"))\n",
    "print(dataset_orig_train.features.shape)\n",
    "display(Markdown(\"#### Favorable and unfavorable labels\"))\n",
    "print(dataset_orig_train.favorable_label, dataset_orig_train.unfavorable_label)\n",
    "display(Markdown(\"#### Protected attribute names\"))\n",
    "print(dataset_orig_train.protected_attribute_names)\n",
    "display(Markdown(\"#### Privileged and unprivileged protected attribute values\"))\n",
    "print(dataset_orig_train.privileged_protected_attributes, dataset_orig_train.unprivileged_protected_attributes)\n",
    "display(Markdown(\"#### Dataset feature names\"))\n",
    "print(dataset_orig_train.feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Metric for the original datasets (without any classifiers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Original training dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in mean outcomes between unprivileged and privileged groups = -0.203834\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Original validation dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in mean outcomes between unprivileged and privileged groups = -0.196345\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Original test dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in mean outcomes between unprivileged and privileged groups = -0.186479\n"
     ]
    }
   ],
   "source": [
    "metric_orig_train = BinaryLabelDatasetMetric(dataset_orig_train, \n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original training dataset\"))\n",
    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_train.mean_difference())\n",
    "\n",
    "metric_orig_valid = BinaryLabelDatasetMetric(dataset_orig_valid, \n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original validation dataset\"))\n",
    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_valid.mean_difference())\n",
    "\n",
    "metric_orig_test = BinaryLabelDatasetMetric(dataset_orig_test, \n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original test dataset\"))\n",
    "print(\"Difference in mean outcomes between unprivileged and privileged groups = %f\" % metric_orig_test.mean_difference())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train classifier (logistic regression on original training data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "# Placeholder for predicted and transformed datasets\n",
    "dataset_orig_train_pred = dataset_orig_train.copy(deepcopy=True)\n",
    "dataset_orig_valid_pred = dataset_orig_valid.copy(deepcopy=True)\n",
    "dataset_orig_test_pred = dataset_orig_test.copy(deepcopy=True)\n",
    "\n",
    "dataset_new_valid_pred = dataset_orig_valid.copy(deepcopy=True)\n",
    "dataset_new_test_pred = dataset_orig_test.copy(deepcopy=True)\n",
    "\n",
    "# Logistic regression classifier and predictions for training data\n",
    "scale_orig = StandardScaler()\n",
    "X_train = scale_orig.fit_transform(dataset_orig_train.features)\n",
    "y_train = dataset_orig_train.labels.ravel()\n",
    "lmod = LogisticRegression()\n",
    "lmod.fit(X_train, y_train)\n",
    "\n",
    "fav_idx = np.where(lmod.classes_ == dataset_orig_train.favorable_label)[0][0]\n",
    "y_train_pred_prob = lmod.predict_proba(X_train)[:,fav_idx]\n",
    "\n",
    "# Prediction probs for validation and testing data\n",
    "X_valid = scale_orig.transform(dataset_orig_valid.features)\n",
    "y_valid_pred_prob = lmod.predict_proba(X_valid)[:,fav_idx]\n",
    "\n",
    "X_test = scale_orig.transform(dataset_orig_test.features)\n",
    "y_test_pred_prob = lmod.predict_proba(X_test)[:,fav_idx]\n",
    "\n",
    "class_thresh = 0.5\n",
    "dataset_orig_train_pred.scores = y_train_pred_prob.reshape(-1,1)\n",
    "dataset_orig_valid_pred.scores = y_valid_pred_prob.reshape(-1,1)\n",
    "dataset_orig_test_pred.scores = y_test_pred_prob.reshape(-1,1)\n",
    "\n",
    "y_train_pred = np.zeros_like(dataset_orig_train_pred.labels)\n",
    "y_train_pred[y_train_pred_prob >= class_thresh] = dataset_orig_train_pred.favorable_label\n",
    "y_train_pred[~(y_train_pred_prob >= class_thresh)] = dataset_orig_train_pred.unfavorable_label\n",
    "dataset_orig_train_pred.labels = y_train_pred\n",
    "\n",
    "y_valid_pred = np.zeros_like(dataset_orig_valid_pred.labels)\n",
    "y_valid_pred[y_valid_pred_prob >= class_thresh] = dataset_orig_valid_pred.favorable_label\n",
    "y_valid_pred[~(y_valid_pred_prob >= class_thresh)] = dataset_orig_valid_pred.unfavorable_label\n",
    "dataset_orig_valid_pred.labels = y_valid_pred\n",
    "    \n",
    "y_test_pred = np.zeros_like(dataset_orig_test_pred.labels)\n",
    "y_test_pred[y_test_pred_prob >= class_thresh] = dataset_orig_test_pred.favorable_label\n",
    "y_test_pred[~(y_test_pred_prob >= class_thresh)] = dataset_orig_test_pred.unfavorable_label\n",
    "dataset_orig_test_pred.labels = y_test_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Results before post-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Original-Predicted training dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in GFPR between unprivileged and privileged groups\n",
      "-0.12346326139186559\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.08133029716390372\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Original-Predicted validation dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in GFPR between unprivileged and privileged groups\n",
      "-0.11809188113049428\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.1074368103879969\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Original-Predicted testing dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in GFPR between unprivileged and privileged groups\n",
      "-0.1241658588350071\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.10111191584552565\n"
     ]
    }
   ],
   "source": [
    "cm_pred_train = ClassificationMetric(dataset_orig_train, dataset_orig_train_pred,\n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original-Predicted training dataset\"))\n",
    "print(\"Difference in GFPR between unprivileged and privileged groups\")\n",
    "print(cm_pred_train.difference(cm_pred_train.generalized_false_positive_rate))\n",
    "print(\"Difference in GFNR between unprivileged and privileged groups\")\n",
    "print(cm_pred_train.difference(cm_pred_train.generalized_false_negative_rate))\n",
    "\n",
    "cm_pred_valid = ClassificationMetric(dataset_orig_valid, dataset_orig_valid_pred,\n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original-Predicted validation dataset\"))\n",
    "print(\"Difference in GFPR between unprivileged and privileged groups\")\n",
    "print(cm_pred_valid.difference(cm_pred_valid.generalized_false_positive_rate))\n",
    "print(\"Difference in GFNR between unprivileged and privileged groups\")\n",
    "print(cm_pred_valid.difference(cm_pred_valid.generalized_false_negative_rate))\n",
    "\n",
    "cm_pred_test = ClassificationMetric(dataset_orig_test, dataset_orig_test_pred,\n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original-Predicted testing dataset\"))\n",
    "print(\"Difference in GFPR between unprivileged and privileged groups\")\n",
    "print(cm_pred_test.difference(cm_pred_test.generalized_false_positive_rate))\n",
    "print(\"Difference in GFNR between unprivileged and privileged groups\")\n",
    "print(cm_pred_test.difference(cm_pred_test.generalized_false_negative_rate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perform odds equalizing post processing on scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Odds equalizing post-processing algorithm\n",
    "from aif360.algorithms.postprocessing.calibrated_eq_odds_postprocessing import CalibratedEqOddsPostprocessing\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Learn parameters to equalize odds and apply to create a new dataset\n",
    "cpp = CalibratedEqOddsPostprocessing(privileged_groups = privileged_groups,\n",
    "                                     unprivileged_groups = unprivileged_groups,\n",
    "                                     cost_constraint=cost_constraint,\n",
    "                                     seed=randseed)\n",
    "cpp = cpp.fit(dataset_orig_valid, dataset_orig_valid_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transform validation and test data using the post processing algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_transf_valid_pred = cpp.predict(dataset_orig_valid_pred)\n",
    "dataset_transf_test_pred = cpp.predict(dataset_orig_test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Results after post-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Original-Transformed validation dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in GFPR between unprivileged and privileged groups\n",
      "-0.20556830681089272\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "-0.0051972411153999865\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "#### Original-Transformed testing dataset"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference in GFPR between unprivileged and privileged groups\n",
      "-0.2075158843924911\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "-0.01975790939466554\n"
     ]
    }
   ],
   "source": [
    "cm_transf_valid = ClassificationMetric(dataset_orig_valid, dataset_transf_valid_pred,\n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original-Transformed validation dataset\"))\n",
    "print(\"Difference in GFPR between unprivileged and privileged groups\")\n",
    "print(cm_transf_valid.difference(cm_transf_valid.generalized_false_positive_rate))\n",
    "print(\"Difference in GFNR between unprivileged and privileged groups\")\n",
    "print(cm_transf_valid.difference(cm_transf_valid.generalized_false_negative_rate))\n",
    "\n",
    "cm_transf_test = ClassificationMetric(dataset_orig_test, dataset_transf_test_pred,\n",
    "                             unprivileged_groups=unprivileged_groups,\n",
    "                             privileged_groups=privileged_groups)\n",
    "display(Markdown(\"#### Original-Transformed testing dataset\"))\n",
    "print(\"Difference in GFPR between unprivileged and privileged groups\")\n",
    "print(cm_transf_test.difference(cm_transf_test.generalized_false_positive_rate))\n",
    "print(\"Difference in GFNR between unprivileged and privileged groups\")\n",
    "print(cm_transf_test.difference(cm_transf_test.generalized_false_negative_rate))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing: Check if the rates for validation data has gone down\n",
    "assert np.abs(cm_transf_valid.difference(cm_transf_valid.generalized_false_negative_rate)) < np.abs(cm_pred_valid.difference(cm_pred_valid.generalized_false_negative_rate)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Classification thresholds used for validation and parameter selection"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 25/25 [00:14<00:00,  1.67it/s]\n"
     ]
    }
   ],
   "source": [
    "# Thresholds\n",
    "all_thresh = np.linspace(0.01, 0.99, 25)\n",
    "display(Markdown(\"#### Classification thresholds used for validation and parameter selection\"))\n",
    "\n",
    "bef_avg_odds_diff_test = []\n",
    "bef_avg_odds_diff_valid = []\n",
    "aft_avg_odds_diff_test = []\n",
    "aft_avg_odds_diff_valid = []\n",
    "bef_bal_acc_valid = []\n",
    "bef_bal_acc_test = []\n",
    "aft_bal_acc_valid = []\n",
    "aft_bal_acc_test = []\n",
    "for thresh in tqdm(all_thresh):\n",
    "    \n",
    "    dataset_orig_valid_pred_thresh = dataset_orig_valid_pred.copy(deepcopy=True)\n",
    "    dataset_orig_test_pred_thresh = dataset_orig_test_pred.copy(deepcopy=True)\n",
    "    dataset_transf_valid_pred_thresh = dataset_transf_valid_pred.copy(deepcopy=True)\n",
    "    dataset_transf_test_pred_thresh = dataset_transf_test_pred.copy(deepcopy=True)\n",
    "    \n",
    "    # Labels for the datasets from scores\n",
    "    y_temp = np.zeros_like(dataset_orig_valid_pred_thresh.labels)\n",
    "    y_temp[dataset_orig_valid_pred_thresh.scores >= thresh] = dataset_orig_valid_pred_thresh.favorable_label\n",
    "    y_temp[~(dataset_orig_valid_pred_thresh.scores >= thresh)] = dataset_orig_valid_pred_thresh.unfavorable_label\n",
    "    dataset_orig_valid_pred_thresh.labels = y_temp\n",
    "\n",
    "    y_temp = np.zeros_like(dataset_orig_test_pred_thresh.labels)\n",
    "    y_temp[dataset_orig_test_pred_thresh.scores >= thresh] = dataset_orig_test_pred_thresh.favorable_label\n",
    "    y_temp[~(dataset_orig_test_pred_thresh.scores >= thresh)] = dataset_orig_test_pred_thresh.unfavorable_label\n",
    "    dataset_orig_test_pred_thresh.labels = y_temp\n",
    "    \n",
    "    y_temp = np.zeros_like(dataset_transf_valid_pred_thresh.labels)\n",
    "    y_temp[dataset_transf_valid_pred_thresh.scores >= thresh] = dataset_transf_valid_pred_thresh.favorable_label\n",
    "    y_temp[~(dataset_transf_valid_pred_thresh.scores >= thresh)] = dataset_transf_valid_pred_thresh.unfavorable_label\n",
    "    dataset_transf_valid_pred_thresh.labels = y_temp\n",
    "    \n",
    "    y_temp = np.zeros_like(dataset_transf_test_pred_thresh.labels)\n",
    "    y_temp[dataset_transf_test_pred_thresh.scores >= thresh] = dataset_transf_test_pred_thresh.favorable_label\n",
    "    y_temp[~(dataset_transf_test_pred_thresh.scores >= thresh)] = dataset_transf_test_pred_thresh.unfavorable_label\n",
    "    dataset_transf_test_pred_thresh.labels = y_temp\n",
    "    \n",
    "    # Metrics for original validation data\n",
    "    classified_metric_orig_valid = ClassificationMetric(dataset_orig_valid,\n",
    "                                                 dataset_orig_valid_pred_thresh,\n",
    "                                                 unprivileged_groups=unprivileged_groups,\n",
    "                                                 privileged_groups=privileged_groups)\n",
    "    bef_avg_odds_diff_valid.append(classified_metric_orig_valid.equal_opportunity_difference())\n",
    "\n",
    "    bef_bal_acc_valid.append(0.5*(classified_metric_orig_valid.true_positive_rate()+\n",
    "                              classified_metric_orig_valid.true_negative_rate()))\n",
    "\n",
    "    classified_metric_orig_test = ClassificationMetric(dataset_orig_test,\n",
    "                                                 dataset_orig_test_pred_thresh,\n",
    "                                                 unprivileged_groups=unprivileged_groups,\n",
    "                                                 privileged_groups=privileged_groups)\n",
    "    bef_avg_odds_diff_test.append(classified_metric_orig_test.equal_opportunity_difference())\n",
    "    bef_bal_acc_test.append(0.5*(classified_metric_orig_test.true_positive_rate()+\n",
    "                              classified_metric_orig_test.true_negative_rate()))\n",
    "\n",
    "    # Metrics for transf validing data\n",
    "    classified_metric_transf_valid = ClassificationMetric(\n",
    "                                     dataset_orig_valid, \n",
    "                                     dataset_transf_valid_pred_thresh,\n",
    "                                     unprivileged_groups=unprivileged_groups,\n",
    "                                     privileged_groups=privileged_groups)\n",
    "    aft_avg_odds_diff_valid.append(classified_metric_transf_valid.equal_opportunity_difference())\n",
    "    aft_bal_acc_valid.append(0.5*(classified_metric_transf_valid.true_positive_rate()+\n",
    "                              classified_metric_transf_valid.true_negative_rate()))\n",
    "\n",
    "    # Metrics for transf validation data\n",
    "    classified_metric_transf_test = ClassificationMetric(dataset_orig_test,\n",
    "                                                 dataset_transf_test_pred_thresh,\n",
    "                                                 unprivileged_groups=unprivileged_groups,\n",
    "                                                 privileged_groups=privileged_groups)\n",
    "    aft_avg_odds_diff_test.append(classified_metric_transf_test.equal_opportunity_difference())\n",
    "    aft_bal_acc_test.append(0.5*(classified_metric_transf_test.true_positive_rate()+\n",
    "                                  classified_metric_transf_test.true_negative_rate()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x115b38b10>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bef_bal_acc_valid = np.array(bef_bal_acc_valid)\n",
    "bef_avg_odds_diff_valid = np.array(bef_avg_odds_diff_valid)\n",
    "\n",
    "aft_bal_acc_valid = np.array(aft_bal_acc_valid)\n",
    "aft_avg_odds_diff_valid = np.array(aft_avg_odds_diff_valid)\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(13,7))\n",
    "ax1.plot(all_thresh, bef_bal_acc_valid, color='b')\n",
    "ax1.plot(all_thresh, aft_bal_acc_valid, color='b', linestyle='dashed')\n",
    "ax1.set_title('Original and Postprocessed validation data', fontsize=16, fontweight='bold')\n",
    "ax1.set_xlabel('Classification Thresholds', fontsize=16, fontweight='bold')\n",
    "ax1.set_ylabel('Balanced Accuracy', color='b', fontsize=16, fontweight='bold')\n",
    "ax1.xaxis.set_tick_params(labelsize=14)\n",
    "ax1.yaxis.set_tick_params(labelsize=14)\n",
    "\n",
    "ax2 = ax1.twinx()\n",
    "ax2.plot(all_thresh, np.abs(bef_avg_odds_diff_valid), color='r')\n",
    "ax2.plot(all_thresh, np.abs(aft_avg_odds_diff_valid), color='r', linestyle='dashed')\n",
    "ax2.set_ylabel('abs(Equal opportunity diff)', color='r', fontsize=16, fontweight='bold')\n",
    "ax2.yaxis.set_tick_params(labelsize=14)\n",
    "ax2.grid(True)\n",
    "fig.legend([\"Balanced Acc. - Orig.\", \"Balanced Acc. - Postproc.\",\n",
    "             \"Equal opp. diff. - Orig.\",\"Equal opp. diff. - Postproc.\",], \n",
    "           fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x115e25050>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bef_bal_acc_test = np.array(bef_bal_acc_test)\n",
    "bef_avg_odds_diff_test = np.array(bef_avg_odds_diff_test)\n",
    "\n",
    "aft_bal_acc_test = np.array(aft_bal_acc_test)\n",
    "aft_avg_odds_diff_test = np.array(aft_avg_odds_diff_test)\n",
    "\n",
    "fig, ax1 = plt.subplots(figsize=(13,7))\n",
    "ax1.plot(all_thresh, bef_bal_acc_test, color='b')\n",
    "ax1.plot(all_thresh, aft_bal_acc_test, color='b', linestyle='dashed')\n",
    "ax1.set_title('Original and Postprocessed testing data', fontsize=16, fontweight='bold')\n",
    "ax1.set_xlabel('Classification Thresholds', fontsize=16, fontweight='bold')\n",
    "ax1.set_ylabel('Balanced Accuracy', color='b', fontsize=16, fontweight='bold')\n",
    "ax1.xaxis.set_tick_params(labelsize=14)\n",
    "ax1.yaxis.set_tick_params(labelsize=14)\n",
    "\n",
    "\n",
    "ax2 = ax1.twinx()\n",
    "ax2.plot(all_thresh, np.abs(bef_avg_odds_diff_test), color='r')\n",
    "ax2.plot(all_thresh, np.abs(aft_avg_odds_diff_test), color='r', linestyle='dashed')\n",
    "ax2.set_ylabel('abs(Equal opportunity diff)', color='r', fontsize=16, fontweight='bold')\n",
    "ax2.yaxis.set_tick_params(labelsize=14)\n",
    "ax2.grid(True)\n",
    "fig.legend([\"Balanced Acc. - Orig.\", \"Balanced Acc. - Postproc.\",\n",
    "            \"Equal opp. diff. - Orig.\", \"Equal opp. diff. - Postproc.\"], \n",
    "           fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}