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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install git+https://git@github.com/bhomass/AIF360.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:No module named 'tensorflow': AdversarialDebiasing will be unavailable. To install, run:\n",
      "pip install 'aif360[AdversarialDebiasing]'\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# Load all necessary packages\n",
    "import sys\n",
    "sys.path.insert(1, \"../\")  \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": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: aif360[AdversarialDebiasing] in /home/bruce/anaconda3/lib/python3.6/site-packages (0.3.0)\n",
      "Requirement already satisfied: numpy>=1.16 in /home/bruce/anaconda3/lib/python3.6/site-packages (from aif360[AdversarialDebiasing]) (1.19.0)\n",
      "Requirement already satisfied: matplotlib in /home/bruce/anaconda3/lib/python3.6/site-packages (from aif360[AdversarialDebiasing]) (3.1.1)\n",
      "Requirement already satisfied: scikit-learn>=0.21 in /home/bruce/anaconda3/lib/python3.6/site-packages (from aif360[AdversarialDebiasing]) (0.23.1)\n",
      "Requirement already satisfied: scipy>=1.2.0 in /home/bruce/anaconda3/lib/python3.6/site-packages (from aif360[AdversarialDebiasing]) (1.4.1)\n",
      "Requirement already satisfied: pandas>=0.24.0 in /home/bruce/anaconda3/lib/python3.6/site-packages (from aif360[AdversarialDebiasing]) (1.0.4)\n",
      "Collecting tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"\n",
      "  Using cached tensorflow-1.15.3-cp36-cp36m-manylinux2010_x86_64.whl (110.5 MB)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /home/bruce/anaconda3/lib/python3.6/site-packages (from matplotlib->aif360[AdversarialDebiasing]) (2.7.3)\n",
      "Requirement already satisfied: cycler>=0.10 in /home/bruce/anaconda3/lib/python3.6/site-packages (from matplotlib->aif360[AdversarialDebiasing]) (0.10.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /home/bruce/anaconda3/lib/python3.6/site-packages (from matplotlib->aif360[AdversarialDebiasing]) (2.2.0)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /home/bruce/anaconda3/lib/python3.6/site-packages (from matplotlib->aif360[AdversarialDebiasing]) (1.0.1)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/bruce/anaconda3/lib/python3.6/site-packages (from scikit-learn>=0.21->aif360[AdversarialDebiasing]) (0.15.1)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/bruce/anaconda3/lib/python3.6/site-packages (from scikit-learn>=0.21->aif360[AdversarialDebiasing]) (2.1.0)\n",
      "Requirement already satisfied: pytz>=2017.2 in /home/bruce/anaconda3/lib/python3.6/site-packages (from pandas>=0.24.0->aif360[AdversarialDebiasing]) (2018.4)\n",
      "Processing /home/bruce/.cache/pip/wheels/93/2a/eb/e58dbcbc963549ee4f065ff80a59f274cc7210b6eab962acdc/termcolor-1.1.0-py3-none-any.whl\n",
      "Requirement already satisfied: six>=1.10.0 in /home/bruce/anaconda3/lib/python3.6/site-packages (from tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (1.12.0)\n",
      "Processing /home/bruce/.cache/pip/wheels/c3/af/84/3962a6af7b4ab336e951b7877dcfb758cf94548bb1771e0679/absl_py-0.9.0-py3-none-any.whl\n",
      "Processing /home/bruce/.cache/pip/wheels/32/42/7f/23cae9ff6ef66798d00dc5d659088e57dbba01566f6c60db63/wrapt-1.12.1-cp36-cp36m-linux_x86_64.whl\n",
      "Collecting astor>=0.6.0\n",
      "  Using cached astor-0.8.1-py2.py3-none-any.whl (27 kB)\n",
      "Collecting tensorboard<1.16.0,>=1.15.0\n",
      "  Using cached tensorboard-1.15.0-py3-none-any.whl (3.8 MB)\n",
      "Collecting grpcio>=1.8.6\n",
      "  Using cached grpcio-1.30.0-cp36-cp36m-manylinux2010_x86_64.whl (3.0 MB)\n",
      "Collecting keras-applications>=1.0.8\n",
      "  Using cached Keras_Applications-1.0.8-py3-none-any.whl (50 kB)\n",
      "Collecting tensorflow-estimator==1.15.1\n",
      "  Using cached tensorflow_estimator-1.15.1-py2.py3-none-any.whl (503 kB)\n",
      "Collecting keras-preprocessing>=1.0.5\n",
      "  Using cached Keras_Preprocessing-1.1.2-py2.py3-none-any.whl (42 kB)\n",
      "Requirement already satisfied: gast==0.2.2 in /home/bruce/anaconda3/lib/python3.6/site-packages (from tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (0.2.2)\n",
      "Collecting google-pasta>=0.1.6\n",
      "  Using cached google_pasta-0.2.0-py3-none-any.whl (57 kB)\n",
      "Requirement already satisfied: protobuf>=3.6.1 in /home/bruce/anaconda3/lib/python3.6/site-packages (from tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (3.12.2)\n",
      "Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /home/bruce/anaconda3/lib/python3.6/site-packages (from tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (0.33.4)\n",
      "Collecting opt-einsum>=2.3.2\n",
      "  Using cached opt_einsum-3.2.1-py3-none-any.whl (63 kB)\n",
      "Requirement already satisfied: setuptools in /home/bruce/anaconda3/lib/python3.6/site-packages (from kiwisolver>=1.0.1->matplotlib->aif360[AdversarialDebiasing]) (41.0.1)\n",
      "Collecting markdown>=2.6.8\n",
      "  Using cached Markdown-3.2.2-py3-none-any.whl (88 kB)\n",
      "Requirement already satisfied: werkzeug>=0.11.15 in /home/bruce/anaconda3/lib/python3.6/site-packages (from tensorboard<1.16.0,>=1.15.0->tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (0.14.1)\n",
      "Requirement already satisfied: h5py in /home/bruce/anaconda3/lib/python3.6/site-packages (from keras-applications>=1.0.8->tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (2.7.1)\n",
      "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /home/bruce/anaconda3/lib/python3.6/site-packages (from markdown>=2.6.8->tensorboard<1.16.0,>=1.15.0->tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (1.6.1)\n",
      "Requirement already satisfied: zipp>=0.5 in /home/bruce/anaconda3/lib/python3.6/site-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<1.16.0,>=1.15.0->tensorflow<2,>=1.13.1; extra == \"adversarialdebiasing\"->aif360[AdversarialDebiasing]) (3.1.0)\n",
      "Installing collected packages: termcolor, absl-py, wrapt, astor, markdown, grpcio, tensorboard, keras-applications, tensorflow-estimator, keras-preprocessing, google-pasta, opt-einsum, tensorflow\n",
      "  Attempting uninstall: wrapt\n",
      "    Found existing installation: wrapt 1.10.11\n",
      "\u001b[31mERROR: Cannot uninstall 'wrapt'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.\u001b[0m\n",
      "\u001b[33mWARNING: You are using pip version 20.1; however, version 20.1.1 is available.\n",
      "You should consider upgrading via the '/home/bruce/anaconda3/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install 'aif360[AdversarialDebiasing]'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fairness metrics for original dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file path=/home/bruce/AIF360/aif360/datasets\n"
     ]
    },
    {
     "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 = 2 # 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', 'education-num', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', '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.108292\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.083228\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.113520\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.06050133717759211\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.06083802553212242\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.056772512111247495\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.04429392044064856\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.05518116448914928\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.04547038598725667\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.07270413709855846\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.0012685222313023048\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.07003620009467992\n",
      "Difference in GFNR between unprivileged and privileged groups\n",
      "0.001905488254368981\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:18<00:00,  1.31it/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 0x7f2c29934898>"
      ]
     },
     "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 0x7f2c29844710>"
      ]
     },
     "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 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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}