Analysis_07MAY2019_new.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Causal-model\" data-toc-modified-id=\"Causal-model-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Causal model</a></span><ul class=\"toc-item\"><li><span><a href=\"#Notes\" data-toc-modified-id=\"Notes-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Notes</a></span></li></ul></li><li><span><a href=\"#Data-sets\" data-toc-modified-id=\"Data-sets-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Data sets</a></span><ul class=\"toc-item\"><li><span><a href=\"#Synthetic-data-with-unobservables\" data-toc-modified-id=\"Synthetic-data-with-unobservables-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Synthetic data with unobservables</a></span></li><li><span><a href=\"#Data-without-unobservables\" data-toc-modified-id=\"Data-without-unobservables-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Data without unobservables</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-approach---metrics\" data-toc-modified-id=\"Causal-approach---metrics-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Causal approach - metrics</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>With unobservables in the data</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-model\" data-toc-modified-id=\"Predictive-model-4.1.1\"><span class=\"toc-item-num\">4.1.1&nbsp;&nbsp;</span>Predictive model</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-4.1.2\"><span class=\"toc-item-num\">4.1.2&nbsp;&nbsp;</span>Visual comparison</a></span></li></ul></li><li><span><a href=\"#Without-unobservables\" data-toc-modified-id=\"Without-unobservables-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Without unobservables</a></span><ul class=\"toc-item\"><li><span><a href=\"#Predictive-model\" data-toc-modified-id=\"Predictive-model-4.2.1\"><span class=\"toc-item-num\">4.2.1&nbsp;&nbsp;</span>Predictive model</a></span></li><li><span><a href=\"#Visual-comparison\" data-toc-modified-id=\"Visual-comparison-4.2.2\"><span class=\"toc-item-num\">4.2.2&nbsp;&nbsp;</span>Visual comparison</a></span></li></ul></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Causal model\n",
    "\n",
    "Our model is defined by the probabilistic expression \n",
    "\n",
    "\\begin{equation} \\label{model_disc}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\sum_x \\underbrace{P(Y=0|X=x, T=1)}_\\text{1} \n",
    "\\overbrace{P(T=1|R=r, X=x)}^\\text{2} \n",
    "\\underbrace{P(X=x)}_\\text{3}\n",
    "\\end{equation}\n",
    "\n",
    "which is equal to \n",
    "\n",
    "\\begin{equation}\\label{model_cont}\n",
    "P(Y=0 | \\text{do}(R=r)) = \\int_x P(Y=0|X=x, T=1)P(T=1|R=r, X=x)P(X=x)\n",
    "\\end{equation}\n",
    "\n",
    "for continuous $x$. In the model Z is a latent, unobserved variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment. Model as a graph:\n",
    "\n",
    "![Model as picture](../figures/intervention_model.png \"Intervention model\")\n",
    "\n",
    "For predicting the probability of negative outcome the following should hold because by Pearl $P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0 | R=r, X=x)$ when $X$ is an admissible set:\n",
    "\n",
    "\\begin{equation} \\label{model_pred}\n",
    "P(Y=0 | \\text{do}(R=r), X=x) = P(Y=0|X=x, T=1)P(T=1|R=r, X=x).\n",
    "\\end{equation}\n",
    "\n",
    "Still it should be noted that this prediction takes into account the probability of the individual to be given a positive decision ($T=1$), see second term in \\ref{model_pred}.\n",
    "\n",
    "----\n",
    "\n",
    "### Notes\n",
    "\n",
    "* Equations \\ref{model_disc} and \\ref{model_cont} describe the whole causal effect in the population (the causal effect of changing $r$ over all strata $X$).\n",
    "* Prediction should be possible with \\ref{model_pred}. Both terms can be learned from the data. NB: the probability $P(Y=0 | \\text{do}(R=r), X=x)$ is lowest when the individual $x$ is the most dangerous or the least dangerous. How could we infer/predict the counterfactual \"what is the probability of $Y=0$ if we were to let this individual go?\" has yet to be calculated.\n",
    "* Is the effect of R learned/estimated correctly if it is just plugged in to a predictive model (e.g. logistic regression)? **NO**\n",
    "* $P(Y=0 | do(R=0)) = 0$ only in this application. <!-- My predictive models say that when $r=0$ the probability $P(Y=0) \\approx 0.027$ which would be a natural estimate in another application/scenario (e.g. in medicine the probability of an adverse event when a stronger medicine is distributed to everyone. Then the probability will be close to zero but not exactly zero.) -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as scs\n",
    "import scipy.integrate as si\n",
    "import seaborn as sns\n",
    "import numpy.random as npr\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# Settings\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.rcParams.update({'font.size': 16})\n",
    "plt.rcParams.update({'figure.figsize': (14, 7)})\n",
    "\n",
    "# Suppress deprecation warnings.\n",
    "\n",
    "import warnings\n",
    "\n",
    "\n",
    "def fxn():\n",
    "    warnings.warn(\"deprecated\", DeprecationWarning)\n",
    "\n",
    "\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "    fxn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data sets\n",
    "\n",
    "### Synthetic data with unobservables\n",
    "\n",
    "In the chunk below, we generate the synthetic data as described by Lakkaraju et al. The default values and definitions of $Y$ and $T$ values follow their description.\n",
    "\n",
    "**Parameters**\n",
    "\n",
    "* M = `nJudges_M`, number of judges\n",
    "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
    "* betas $\\beta_i$ = `beta_i`, where $i \\in \\{X, Z, W\\}$ are coefficients for the respected variables\n",
    "\n",
    "**Columns of the data:**\n",
    "\n",
    "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
    "* R = `acceptanceRate_R`, acceptance rates\n",
    "* X = `X`, invidual's features observable to all (models and judges)\n",
    "* Z = `Z`, information observable for judges only\n",
    "* W = `W`, unobservable / inaccessible information\n",
    "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
    "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime.\n",
    "\n",
    "The generated data will have M\\*N rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>result_Y</th>\n",
       "      <th>0.0</th>\n",
       "      <th>1.0</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>decision_T</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>17706</td>\n",
       "      <td>8190</td>\n",
       "      <td>25896</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7302</td>\n",
       "      <td>16802</td>\n",
       "      <td>24104</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>25008</td>\n",
       "      <td>24992</td>\n",
       "      <td>50000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "result_Y      0.0    1.0    All\n",
       "decision_T                     \n",
       "0           17706   8190  25896\n",
       "1            7302  16802  24104\n",
       "All         25008  24992  50000"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set seed for reproducibility\n",
    "#npr.seed(0)\n",
    "\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "\n",
    "def generateData(nJudges_M=100,\n",
    "                 nSubjects_N=500,\n",
    "                 beta_X=1.0,\n",
    "                 beta_Z=1.0,\n",
    "                 beta_W=0.2):\n",
    "\n",
    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
    "    judgeID_J = np.repeat(np.arange(0, nJudges_M, dtype=np.int32), nSubjects_N)\n",
    "\n",
    "    # Sample acceptance rates uniformly from a closed interval\n",
    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
    "\n",
    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
    "    acceptanceRate_R = np.repeat(acceptance_rates, nSubjects_N)\n",
    "\n",
    "    # Sample the variables from standard Gaussian distributions.\n",
    "    X = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "    Z = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "    W = npr.normal(size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    probabilities_Y = sigmoid(beta_X * X + beta_Z * Z + beta_W * W)\n",
    "\n",
    "    # 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
    "    result_Y = 1 - probabilities_Y.round()\n",
    "\n",
    "    # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
    "    probabilities_T = sigmoid(beta_X * X + beta_Z * Z)\n",
    "    probabilities_T += npr.normal(0, np.sqrt(0.1), nJudges_M * nSubjects_N)\n",
    "\n",
    "    # Initialize decision values as 1\n",
    "    decision_T = np.ones(nJudges_M * nSubjects_N)\n",
    "\n",
    "    # Initialize the dataframe\n",
    "    df_init = pd.DataFrame(np.column_stack(\n",
    "        (judgeID_J, acceptanceRate_R, X, Z, W, result_Y, probabilities_T,\n",
    "         decision_T)),\n",
    "                           columns=[\n",
    "                               \"judgeID_J\", \"acceptanceRate_R\", \"X\", \"Z\", \"W\",\n",
    "                               \"result_Y\", \"probabilities_T\", \"decision_T\"\n",
    "                           ])\n",
    "\n",
    "    # Sort by judges then probabilities in decreasing order\n",
    "    data = df_init.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                               ascending=False)\n",
    "\n",
    "    # Iterate over the data. Subject is in the top (1-r)*100% if\n",
    "    # his within-judge-index is over acceptance threshold times\n",
    "    # the number of subjects assigned to each judge. If subject\n",
    "    # is over the limit they are assigned a zero, else one.\n",
    "    data.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    data['decision_T'] = np.where(\n",
    "        (data.index.values % nSubjects_N) <\n",
    "        ((1 - data['acceptanceRate_R']) * nSubjects_N), 0, 1)\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "df = generateData()\n",
    "\n",
    "pd.crosstab(df.decision_T, df.result_Y, margins=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25000, 8)\n",
      "(25000, 8)\n",
      "(25000, 8)\n",
      "(25000, 8)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>decision_T</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>result_Y</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0.0</th>\n",
       "      <td>3650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>8295</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "decision_T     1\n",
       "result_Y        \n",
       "0.0         3650\n",
       "1.0         8295"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split the data set to test and train\n",
    "from sklearn.model_selection import train_test_split\n",
    "train, test = train_test_split(df, test_size=0.5, random_state=0)\n",
    "\n",
    "print(train.shape)\n",
    "print(test.shape)\n",
    "\n",
    "train_labeled = train.copy()\n",
    "test_labeled = test.copy()\n",
    "\n",
    "# Set results as NA if decision is negative.\n",
    "train_labeled.result_Y = np.where(train.decision_T == 0, np.nan,\n",
    "                                  train.result_Y)\n",
    "test_labeled.result_Y = np.where(test.decision_T == 0, np.nan, test.result_Y)\n",
    "\n",
    "print(train_labeled.shape)\n",
    "print(test_labeled.shape)\n",
    "\n",
    "tab = train_labeled.groupby(['result_Y', 'decision_T']).size()\n",
    "tab.unstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data without unobservables\n",
    "\n",
    "In the chunk below, we generate a simplified data. The default values and definitions of $Y$ and $T$ values follow the previous description.\n",
    "\n",
    "**Parameters**\n",
    "\n",
    "* M = `nJudges_M`, number of judges\n",
    "* N = `nSubjects_N`, number of subjects assigned to each judge\n",
    "* betas $\\beta_i$ = `beta_i`, where $i \\in \\{X, Z, W\\}$ are coefficients for the respected variables\n",
    "\n",
    "**Columns of the data:**\n",
    "\n",
    "* `judgeID_J` = judge IDs as running numbering from 0 to `nJudges_M - 1`\n",
    "* R = `acceptanceRate_R`, acceptance rates\n",
    "* X = `X`, invidual's features observable to all (models and judges), now $X \\sim \\mathcal{N}(0, 1)$\n",
    "* T = `decision_T`, bail-or-jail decisions where $T=0$ represents jail decision and $T=1$ bail decision.\n",
    "* $p_y$ = `probabilities_Y`, variable where $p_y = P(Y=1)$\n",
    "* Y = `result_Y`, result variable, if $Y=0$ person will or would recidivate and if $Y=1$ person will or would not commit a crime. Here $Y \\sim \\text{Bernoulli}(1/exp(\\beta_X \\cdot X))$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Whole data:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>result_Y</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>decision_T</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>15829</td>\n",
       "      <td>8834</td>\n",
       "      <td>24663</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9060</td>\n",
       "      <td>16277</td>\n",
       "      <td>25337</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>24889</td>\n",
       "      <td>25111</td>\n",
       "      <td>50000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "result_Y        0      1    All\n",
       "decision_T                     \n",
       "0           15829   8834  24663\n",
       "1            9060  16277  25337\n",
       "All         24889  25111  50000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>result_Y</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>decision_T</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7876</td>\n",
       "      <td>4496</td>\n",
       "      <td>12372</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4504</td>\n",
       "      <td>8124</td>\n",
       "      <td>12628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>12380</td>\n",
       "      <td>12620</td>\n",
       "      <td>25000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "result_Y        0      1    All\n",
       "decision_T                     \n",
       "0            7876   4496  12372\n",
       "1            4504   8124  12628\n",
       "All         12380  12620  25000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test data:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>result_Y</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>decision_T</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7953</td>\n",
       "      <td>4338</td>\n",
       "      <td>12291</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4556</td>\n",
       "      <td>8153</td>\n",
       "      <td>12709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>12509</td>\n",
       "      <td>12491</td>\n",
       "      <td>25000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "result_Y        0      1    All\n",
       "decision_T                     \n",
       "0            7953   4338  12291\n",
       "1            4556   8153  12709\n",
       "All         12509  12491  25000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set seed for reproducibility\n",
    "#npr.seed(0)\n",
    "\n",
    "\n",
    "def generateDataNoUnobservables(nJudges_M=100, nSubjects_N=500, beta_X=1.0):\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "\n",
    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
    "    df = df.assign(judgeID_J=np.repeat(np.arange(0, nJudges_M, dtype=np.int32),\n",
    "                                       nSubjects_N))\n",
    "\n",
    "    # Sample acceptance rates uniformly from a closed interval\n",
    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
    "\n",
    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
    "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
    "\n",
    "    # Sample feature X from standard Gaussian distribution.\n",
    "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-beta_X * x)) = sigmoid(beta_X * x))\n",
    "    df = df.assign(probabilities_Y=sigmoid(beta_X * df.X))\n",
    "\n",
    "    # Draw Y ~ Bernoulli(sigmoid(beta_X * x))\n",
    "    df = df.assign(result_Y=npr.binomial(\n",
    "        n=1, p=df.probabilities_Y, size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Invert the probabilities. ELABORATE COMMENT!\n",
    "    df.probabilities_Y = 1 - df.probabilities_Y\n",
    "\n",
    "    # Sort by judges then probabilities in increasing order.\n",
    "    # I.e. the most dangerous for each judge are first.\n",
    "    df = df.sort_values(by=[\"judgeID_J\", \"probabilities_Y\"], ascending=False)\n",
    "\n",
    "    # Iterate over the data. Subject is in the top (1-r)*100% if\n",
    "    # his within-judge-index is over acceptance threshold times\n",
    "    # the number of subjects assigned to each judge. If subject\n",
    "    # is over the limit they are assigned a zero, else one.\n",
    "    df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
    "                                ((1 - df['acceptanceRate_R']) * nSubjects_N),\n",
    "                                0, 1)\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "simple_data = generateDataNoUnobservables()\n",
    "\n",
    "# Split the data set to test and train\n",
    "s_train, s_test = train_test_split(simple_data, test_size=0.5, random_state=0)\n",
    "\n",
    "s_train_labeled = s_train.copy()\n",
    "s_test_labeled = s_test.copy()\n",
    "\n",
    "# Set results as NA if decision is negative.\n",
    "s_train_labeled.result_Y = np.where(s_train.decision_T == 0, np.nan,\n",
    "                                    s_train.result_Y)\n",
    "s_test_labeled.result_Y = np.where(s_test.decision_T == 0, np.nan,\n",
    "                                   s_test.result_Y)\n",
    "\n",
    "#display(simple_data.tail(20))\n",
    "\n",
    "print(\"Whole data:\")\n",
    "display(\n",
    "    pd.crosstab(simple_data.decision_T, simple_data.result_Y, margins=True), )\n",
    "\n",
    "print(\"Training data:\")\n",
    "display(pd.crosstab(s_train.decision_T, s_train.result_Y, margins=True))\n",
    "\n",
    "print(\"Test data:\")\n",
    "display(pd.crosstab(s_test.decision_T, s_test.result_Y, margins=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algorithms\n",
    "\n",
    "### Contraction algorithm\n",
    "\n",
    "Below is an implementation of Lakkaraju's team's algorithm presented in [their paper](https://helka.finna.fi/PrimoRecord/pci.acm3098066). Relevant parameters to be passed to the function are presented in the description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contraction(df, judgeIDJ_col, decisionT_col, resultY_col, modelProbS_col,\n",
    "                accRateR_col, r):\n",
    "    '''\n",
    "    This is an implementation of the algorithm presented by Lakkaraju\n",
    "    et al. in their paper \"The Selective Labels Problem: Evaluating \n",
    "    Algorithmic Predictions in the Presence of Unobservables\" (2017).\n",
    "    \n",
    "    Parameters:\n",
    "    df = The (Pandas) data frame containing the data, judge decisions,\n",
    "    judge IDs, results and probability scores.\n",
    "    judgeIDJ_col = String, the name of the column containing the judges' IDs\n",
    "    in df.\n",
    "    decisionT_col = String, the name of the column containing the judges' decisions\n",
    "    resultY_col = String, the name of the column containing the realization\n",
    "    modelProbS_col = String, the name of the column containing the probability\n",
    "    scores from the black-box model B.\n",
    "    accRateR_col = String, the name of the column containing the judges' \n",
    "    acceptance rates\n",
    "    r = Float between 0 and 1, the given acceptance rate.\n",
    "    \n",
    "    Returns:\n",
    "    u = The estimated failure rate at acceptance rate r.\n",
    "    '''\n",
    "    # Get ID of the most lenient judge.\n",
    "    most_lenient_ID_q = df[judgeIDJ_col].loc[df[accRateR_col].idxmax()]\n",
    "\n",
    "    # Subset. \"D_q is the set of all observations judged by q.\"\n",
    "    D_q = df[df[judgeIDJ_col] == most_lenient_ID_q].copy()\n",
    "\n",
    "    # All observations of R_q have observed outcome labels.\n",
    "    # \"R_q is the set of observations in D_q with observed outcome labels.\"\n",
    "    R_q = D_q[D_q[decisionT_col] == 1].copy()\n",
    "\n",
    "    # Sort observations in R_q in descending order of confidence scores S and\n",
    "    # assign to R_sort_q.\n",
    "    # \"Observations deemed as high risk by B are at the top of this list\"\n",
    "    R_sort_q = R_q.sort_values(by=modelProbS_col, ascending=False)\n",
    "\n",
    "    number_to_remove = int(\n",
    "        round((1.0 - r) * D_q.shape[0] - (D_q.shape[0] - R_q.shape[0])))\n",
    "\n",
    "    # \"R_B is the list of observations assigned to t = 1 by B\"\n",
    "    R_B = R_sort_q[number_to_remove:R_sort_q.shape[0]]\n",
    "\n",
    "    return np.sum(R_B[resultY_col] == 0) / D_q.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Causal approach - metrics\n",
    "\n",
    "Generalized performance:\n",
    "\n",
    "$$\n",
    "\\mathbf{gp} = \\sum_x f(x)\\delta(F(x) < r)P(X=x)\n",
    "$$\n",
    "\n",
    "and empirical performance:\n",
    "\n",
    "$$\n",
    "\\mathbf{ep} = \\dfrac{1}{n} \\sum_{(x, y) \\in \\mathcal{D}} \\delta(y=0) \\delta(F(x) < r)\n",
    "$$\n",
    "\n",
    "where\n",
    "\n",
    "$$\n",
    "f(x) = P(Y=0|T=1, X=x)\n",
    "$$\n",
    "\n",
    "and\n",
    "\n",
    "$$\n",
    "F(x_0) = \\int P(x)~\\delta(P(Y=0|T=1, X=x) > P(Y=0|T=1, X=x_0)) ~ dx = \\int P(x)~\\delta(f(x) > f(x_0)) ~ dx.\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.58 ms ± 30.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "20.5 ms ± 517 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "177 ms ± 411 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "def getProbabilityForClass(x, model, class_value):\n",
    "    '''\n",
    "    Function (wrapper) for obtaining the probability of a class given x and a \n",
    "    predictive model.\n",
    "    \n",
    "    Parameters:\n",
    "    x = individual features, an array, shape (observations, features)\n",
    "    model = a trained sklearn model. Predicts probabilities for given x. Should\n",
    "    accept input of size (observations, features)\n",
    "    class_value = the resulting class to predict (usually 0 or 1).\n",
    "    \n",
    "    Returns:\n",
    "    The probabilities of given class label for each x.\n",
    "    '''\n",
    "    if x.ndim == 1:\n",
    "        # if x is vector, transform to column matrix.\n",
    "        f_values = model.predict_proba(np.array(x).reshape(-1, 1))\n",
    "    else:\n",
    "        f_values = model.predict_proba(x)\n",
    "\n",
    "    # Get correct column of predicted class, remove extra dimensions and return.\n",
    "    return f_values[:, model.classes_ == class_value].flatten()\n",
    "\n",
    "\n",
    "def cdf(x_0, model, class_value):\n",
    "    '''\n",
    "    Cumulative distribution function as described above.\n",
    "    \n",
    "    '''\n",
    "    prediction = lambda x: getProbabilityForClass(\n",
    "        np.array([x]).reshape(-1, 1), model, class_value)\n",
    "\n",
    "    prediction_x_0 = prediction(x_0)\n",
    "\n",
    "    x_values = np.linspace(-10, 10, 40000)\n",
    "\n",
    "    x_preds = prediction(x_values)\n",
    "\n",
    "    y_values = scs.norm.pdf(x_values)\n",
    "\n",
    "    results = np.zeros(x_0.shape[0])\n",
    "\n",
    "    for i in range(x_0.shape[0]):\n",
    "        \n",
    "        y_copy = y_values.copy()\n",
    "        \n",
    "        y_copy[prediction(x_values) < prediction_x_0[i]] = 0\n",
    "        \n",
    "        results[i] = si.simps(y_copy, x=x_values)\n",
    "\n",
    "    return results\n",
    "\n",
    "\n",
    "%timeit cdf(np.ones(1), logreg, 0)\n",
    "%timeit cdf(np.ones(10), logreg, 0)\n",
    "%timeit cdf(np.ones(100), logreg, 0)\n",
    "#%timeit cdf(np.ones(1000), logreg, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance comparison\n",
    "\n",
    "Below we try to replicate the results obtained by Lakkaraju and compare their model's performance to the one of ours.\n",
    "\n",
    "### With unobservables in the data\n",
    "\n",
    "#### Predictive model\n",
    "\n",
    "Lakkaraju says that they used logistic regression. We train the predictive models using only *observed observations*, i.e. observations for which labels are available. We then predict the probability of negative outcome for all observations in the test data and attach it to our data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate the model (using the default parameters)\n",
    "logreg = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "# fit, reshape X to be of shape (n_samples, n_features)\n",
    "logreg = logreg.fit(\n",
    "    train_labeled.dropna().X.values.reshape(-1, 1),\n",
    "    train_labeled.result_Y.dropna())\n",
    "\n",
    "# predict probabilities and attach to data\n",
    "label_probs_logreg = logreg.predict_proba(test.X.values.reshape(-1, 1))\n",
    "\n",
    "test = test.assign(B_prob_0_logreg=label_probs_logreg[:, 0])\n",
    "test_labeled = test_labeled.assign(B_prob_0_logreg=label_probs_logreg[:, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We train another logistic regression model for predicting the probability of positive decision with a given leniency r  and individual features x. See part 2 of eq. 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the model (using the default parameters)\n",
    "decision_model = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "# fit, reshape X to be of shape (n_samples, n_features)\n",
    "decision_model = decision_model.fit(train[['X', 'acceptanceRate_R']],\n",
    "                                    train.decision_T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visual comparison\n",
    "\n",
    "Let's plot the failure rates against the acceptance rates using the difference. For the causal model we plot $P(Y=0|do(R=r))$ against r."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "failure_rates = np.zeros((8, 5))\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "\n",
    "    #### True evaluation\n",
    "    # Sort by failure probabilities, subjects with the smallest risk are first.\n",
    "    test.sort_values(by='B_prob_0_logreg', inplace=True, ascending=True)\n",
    "\n",
    "    to_release = int(round(test.shape[0] * r / 10))\n",
    "\n",
    "    # Calculate failure rate as the ratio of failures to successes among those\n",
    "    # who were given a positive decision, i.e. those whose probability of negative\n",
    "    # outcome was low enough.\n",
    "    failure_rates[r - 1, 0] = np.sum(\n",
    "        test.result_Y[0:to_release] == 0) / test.shape[0]\n",
    "\n",
    "    #### Labeled outcomes only\n",
    "    # Sort by failure probabilities, subjects with the smallest risk are first.\n",
    "    test_labeled.sort_values(by='B_prob_0_logreg',\n",
    "                             inplace=True,\n",
    "                             ascending=True)\n",
    "\n",
    "    to_release = int(round(test_labeled.shape[0] * r / 10))\n",
    "\n",
    "    failure_rates[r - 1, 1] = np.sum(\n",
    "        test_labeled.result_Y[0:to_release] == 0) / test_labeled.shape[0]\n",
    "\n",
    "    #### Human error rate\n",
    "    # Get judges with correct leniency as list\n",
    "    correct_leniency_list = test_labeled.judgeID_J[\n",
    "        test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
    "\n",
    "    # Released are the people they judged and released, T = 1\n",
    "    released = test_labeled[test_labeled.judgeID_J.isin(correct_leniency_list)\n",
    "                            & (test_labeled.decision_T == 1)]\n",
    "\n",
    "    # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
    "    failure_rates[r - 1, 2] = np.sum(\n",
    "        released.result_Y == 0) / correct_leniency_list.shape[0]\n",
    "\n",
    "    #### Contraction, logistic regression\n",
    "    failure_rates[r - 1, 3] = contraction(test_labeled, 'judgeID_J',\n",
    "                                          'decision_T', 'result_Y',\n",
    "                                          'B_prob_0_logreg',\n",
    "                                          'acceptanceRate_R', r / 10)\n",
    "\n",
    "    #### Causal effect\n",
    "    # Integral of P(Y=0 | T=1, X=x)*P(T=1 | R=r, X=x)*P(X=x) from negative to\n",
    "    # positive infinity.\n",
    "    failure_rates[r - 1, 4] = np.sum((test_labeled.dropna().result_Y == 0) & (\n",
    "        cdf(test_labeled.dropna().X, logreg, 0) < r /\n",
    "        10)) / test_labeled.dropna().result_Y.shape[0]\n",
    "\n",
    "# Error bars TBA\n",
    "\n",
    "plt.figure(figsize=(14, 8))\n",