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$. Model as a graph (Z is a latent variable, and can be excluded from the expression with do-calculus by showing that $X$ is admissible for adjustment):\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)?\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": 52,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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>17263</td>\n",
       "      <td>7585</td>\n",
       "      <td>24848</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7931</td>\n",
       "      <td>17221</td>\n",
       "      <td>25152</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>25194</td>\n",
       "      <td>24806</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           17263   7585  24848\n",
       "1            7931  17221  25152\n",
       "All         25194  24806  50000"
      ]
     },
     "execution_count": 53,
     "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": 54,
   "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>3922</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1.0</th>\n",
       "      <td>8566</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "decision_T     1\n",
       "result_Y        \n",
       "0.0         3922\n",
       "1.0         8566"
      ]
     },
     "execution_count": 54,
     "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": 55,
   "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>16220</td>\n",
       "      <td>8743</td>\n",
       "      <td>24963</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8889</td>\n",
       "      <td>16148</td>\n",
       "      <td>25037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>25109</td>\n",
       "      <td>24891</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           16220   8743  24963\n",
       "1            8889  16148  25037\n",
       "All         25109  24891  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>8144</td>\n",
       "      <td>4335</td>\n",
       "      <td>12479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4375</td>\n",
       "      <td>8146</td>\n",
       "      <td>12521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>12519</td>\n",
       "      <td>12481</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            8144   4335  12479\n",
       "1            4375   8146  12521\n",
       "All         12519  12481  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>8076</td>\n",
       "      <td>4408</td>\n",
       "      <td>12484</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4514</td>\n",
       "      <td>8002</td>\n",
       "      <td>12516</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>12590</td>\n",
       "      <td>12410</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            8076   4408  12484\n",
       "1            4514   8002  12516\n",
       "All         12590  12410  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": 56,
   "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": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.67 ms ± 65.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "20.4 ms ± 329 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "187 ms ± 5.24 ms 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": 74,
   "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": 59,
   "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": 82,
   "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",
    "plt.plot(np.arange(0.1, 0.9, .1),\n",
    "         failure_rates[:, 0],\n",