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=\"#Data-sets\" data-toc-modified-id=\"Data-sets-1\"><span class=\"toc-item-num\">1&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-1.1\"><span class=\"toc-item-num\">1.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-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Data without unobservables</a></span></li></ul></li><li><span><a href=\"#Algorithms\" data-toc-modified-id=\"Algorithms-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Algorithms</a></span><ul class=\"toc-item\"><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Causal-approach---metrics\" data-toc-modified-id=\"Causal-approach---metrics-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Causal approach - metrics</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-3\"><span class=\"toc-item-num\">3&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-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>With unobservables in the data</a></span></li><li><span><a href=\"#Without-unobservables\" data-toc-modified-id=\"Without-unobservables-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Without unobservables</a></span></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.) -->\n",
    "\n",
    "Imports and settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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",
    "from sklearn.model_selection import train_test_split\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": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    '''Return value of sigmoid function (inverse of logit) at x.'''\n",
    "\n",
    "    return 1 / (1 + np.exp(-1*x))\n",
    "\n",
    "\n",
    "def dataWithUnobservables(nJudges_M=100,\n",
    "                          nSubjects_N=500,\n",
    "                          beta_X=1.0,\n",
    "                          beta_Z=1.0,\n",
    "                          beta_W=0.2):\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(range(0, nJudges_M), 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 the variables from standard Gaussian distributions.\n",
    "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "    df = df.assign(Z=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "    df = df.assign(W=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Calculate P(Y=0|X, Z, W)\n",
    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
    "\n",
    "    df = df.assign(probabilities_Y=probabilities_Y)\n",
    "\n",
    "    # Result is 0 if P(Y = 0| X = x; Z = z; W = w) >= 0.5 , 1 otherwise\n",
    "    df = df.assign(result_Y=np.where(df.probabilities_Y >= 0.5, 0, 1))\n",
    "\n",
    "    # For the conditional probabilities of T we add noise ~ N(0, 0.1)\n",
    "    probabilities_T = sigmoid(beta_X * df.X + beta_Z * df.Z)\n",
    "    probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    df = df.assign(probabilities_T=probabilities_T)\n",
    "\n",
    "    # Sort by judges then probabilities in decreasing order\n",
    "    # Most dangerous for each judge are at the top.\n",
    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                   ascending=False,\n",
    "                   inplace=True)\n",
    "\n",
    "    # Iterate over the data. Subject will be given a negative decision\n",
    "    # if they are in the top (1-r)*100% of the individuals the judge will judge.\n",
    "    # I.e. if their within-judge-index is under 1 - acceptance threshold times\n",
    "    # the number of subjects assigned to each judge they will receive a\n",
    "    # negative decision.\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",
    "    # Halve the data set to test and train\n",
    "    train, test = train_test_split(df, test_size=0.5)\n",
    "\n",
    "    train_labeled = train.copy()\n",
    "    test_labeled = test.copy()\n",
    "\n",
    "    # Set results as NA if decision is negative.\n",
    "    train_labeled.loc[train_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "    test_labeled.loc[test_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "\n",
    "    return train_labeled, train, test_labeled, test, df"
   ]
  },
  {
   "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",
    "* $\\beta_X$ = `beta_X`, coefficient for $X$\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=0)$\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}(\\frac{1}{1+exp\\{-\\beta_X \\cdot X\\}})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dataWithoutUnobservables(nJudges_M=100,\n",
    "                             nSubjects_N=500,\n",
    "                             sigma=0.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(range(0, nJudges_M), 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(0, 1).\n",
    "    df = df.assign(X=npr.normal(size=nJudges_M * nSubjects_N))\n",
    "\n",
    "    # Calculate P(Y=1|X=x) = 1 / (1 + exp(-beta_X * x)) = sigmoid(beta_X * x)\n",
    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
    "\n",
    "    # Draw Y ~ Bernoulli(sigmoid(beta_X * x)) = Bin(1, p)\n",
    "    results = npr.binomial(n=1, p=1 - df.probabilities_Y,\n",
    "                           size=nJudges_M * nSubjects_N)\n",
    "\n",
    "    df = df.assign(result_Y=results)\n",
    "\n",
    "    # Invert the probabilities. P(Y=0 | X) = 1 - P(Y=1 | X)\n",
    "    #df.probabilities_Y = 1 - df.probabilities_Y\n",
    "\n",
    "    # Assign the prediction probabilities and add some Gaussian noise\n",
    "    # if sigma is set to != 0.\n",
    "    df = df.assign(probabilities_T=df.probabilities_Y)\n",
    "\n",
    "    df.probabilities_T += npr.normal(size=nJudges_M * nSubjects_N) * sigma\n",
    "\n",
    "    # Sort by judges then probabilities in decreasing order\n",
    "    # I.e. the most dangerous for each judge are first.\n",
    "    df.sort_values(by=[\"judgeID_J\", \"probabilities_T\"],\n",
    "                   ascending=False,\n",
    "                   inplace=True)\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",
    "    # Halve the data set to test and train\n",
    "    train, test = train_test_split(df, test_size=0.5)\n",
    "\n",
    "    train_labeled = train.copy()\n",
    "    test_labeled = test.copy()\n",
    "\n",
    "    # Set results as NA if decision is negative.\n",
    "    train_labeled.loc[train_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "    test_labeled.loc[test_labeled.decision_T == 0, 'result_Y'] = np.nan\n",
    "\n",
    "    return train_labeled, train, test_labeled, test, df"
   ]
  },
  {
   "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": 4,
   "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",
    "    Arguments:\n",
    "    -----------\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",
    "    --------\n",
    "    (1) 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\\in\\mathcal{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}_{test}} f(x) ~ \\delta(F(x) < r)\n",
    "$$\n",
    "\n",
    "where\n",
    "\n",
    "$$\n",
    "f(x) = P(Y=0|T=1, X=x)\n",
    "$$\n",
    "\n",
    "is a predictive model trained on the labeled data 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",
    "\n",
    "NB: in code the direction of inequality was changed. CDF changed to `bailIndicator` algorithm.\n",
    "\n",
    "**Rationale for `bailIndicator`:**\n",
    "\n",
    "* Bail decision is based on prediction $P(Y=0|T=1, X=x)$.\n",
    "    * Uniform over all judges\n",
    "* Judges rationing: \"If this defendant is in the top 10% of 'dangerousness rank' and my $r = 0.85$, I will jail him.\"\n",
    "* Overall: this kind of defendant $(X=x)$ is usually in the $z^{th}$ percentile in dangerousness (sd $\\pm~u$ percentiles). Now, what is the probability that this defendant has $z \\leq 1-r$?\n",
    "\n",
    "\n",
    "<!--- **Proposal**\n",
    "\n",
    "1. Train model for $P(Y=0|T=1, X=x)$\n",
    "* Estimate quantile function for $P(T=1|R=r, X=x)$\n",
    "* Calculate $P(Y=0|do(r'), do(x'))=P(Y=0|T=1, X=x') \\cdot P(T=1|R=r', X=x')$ for all instances of the training data\n",
    "* Order in ascending order based on the probabilities obtained from previous step\n",
    "* Calculate $$\\dfrac{\\sum_{i=0}^{r\\cdot |\\mathcal{D}_{all}|}}{|\\mathcal{D}_{all}|}$$--->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "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",
    "    Arguments:\n",
    "    -----------\n",
    "    x -- individual features, an array of shape (observations, features)\n",
    "    model -- a trained sklearn model. Predicts probabilities for given x. \n",
    "        Should accept input of shape (observations, features)\n",
    "    class_value -- the resulting class to predict (usually 0 or 1).\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) 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. Integral is \n",
    "    approximated using Simpson's rule for efficiency.\n",
    "    \n",
    "    Arguments:\n",
    "    ----------\n",
    "    \n",
    "    x_0 -- private features of an instance for which the value of cdf is to be\n",
    "        calculated.\n",
    "    model -- a trained sklearn model. Predicts probabilities for given x. \n",
    "        Should accept input of shape (observations, features)\n",
    "    class_value -- the resulting class to predict (usually 0 or 1).\n",
    "\n",
    "    '''\n",
    "    def prediction(x): return 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[x_preds > prediction_x_0[i]] = 0\n",
    "\n",
    "        results[i] = si.simps(y_copy, x=x_values)\n",
    "\n",
    "    return results\n",
    "\n",
    "\n",
    "def bailIndicator(r, y_model, x_train, x_test):\n",
    "    '''\n",
    "    Indicator function for whether a judge will bail or jail a suspect.\n",
    "    Rationale explained above.\n",
    "\n",
    "    Algorithm:\n",
    "    ----------\n",
    "\n",
    "    (1) Calculate recidivism probabilities from training set with a trained \n",
    "        model and assign them to predictions_train.\n",
    "\n",
    "    (2) Calculate recidivism probabilities from test set with the trained \n",
    "        model and assign them to predictions_test.\n",
    "\n",
    "    (3) Construct a quantile function of the probabilities in\n",
    "        in predictions_train.\n",
    "\n",
    "    (4)\n",
    "    For pred in predictions_test:\n",
    "\n",
    "        if pred belongs to a percentile (computed from step (3)) lower than r\n",
    "            return True\n",
    "        else\n",
    "            return False\n",
    "\n",
    "    Arguments:\n",
    "    ----------\n",
    "\n",
    "    r -- float, acceptance rate, between 0 and 1\n",
    "    y_model -- a trained sklearn predictive model to predict the outcome\n",
    "    x_train -- private features of the training instances\n",
    "    x_test -- private features of the test instances\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Boolean list indicating a bail decision (bail = True) for each \n",
    "        instance in x_test.\n",
    "    '''\n",
    "\n",
    "    predictions_train = getProbabilityForClass(x_train, y_model, 0)\n",
    "\n",
    "    predictions_test = getProbabilityForClass(x_test, y_model, 0)\n",
    "\n",
    "    return [\n",
    "        scs.percentileofscore(predictions_train, pred, kind='weak') < r\n",
    "        for pred in predictions_test\n",
    "    ]\n",
    "\n",
    "\n",
    "def estimatePercentiles(x_train, y_model, N_bootstraps=2000, N_sample=100):\n",
    "    '''\n",
    "    Estimate percentiles based on bootstrapped samples of original data.\n",
    "    Bootstrapping is done N_bootstraps times and size of the sample is\n",
    "    N_sample.\n",
    "\n",
    "\n",
    "    '''\n",
    "\n",
    "    res = np.zeros((N_bootstraps, 101))\n",
    "\n",
    "    percs = np.arange(101)\n",
    "\n",
    "    for i in range(N_bootstraps):\n",
    "\n",
    "        sample = npr.choice(x_train, size=N_sample)\n",
    "\n",
    "        predictions_sample = getProbabilityForClass(sample, y_model, 0)\n",
    "\n",
    "        res[i, :] = np.percentile(predictions_sample, percs)\n",
    "\n",
    "    return res\n",
    "\n",
    "\n",
    "def calcReleaseProbabilities(r,\n",
    "                             x_train,\n",
    "                             x_test,\n",
    "                             y_model,\n",
    "                             N_bootstraps=2000,\n",
    "                             N_sample=100,\n",
    "                             percentileMatrix=None):\n",
    "    '''\n",
    "    Similar to bailIndicator, but calculates probabilities for bail decisions\n",
    "    by bootstrapping the data set.\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Probabilities for positive bail decisions.\n",
    "    '''\n",
    "\n",
    "    if percentileMatrix is None:\n",
    "        percentileMatrix = estimatePercentiles(x_train, y_model, N_bootstraps,\n",
    "                                               N_sample)\n",
    "\n",
    "    probs = np.zeros(len(x_test))\n",
    "\n",
    "    for i in range(len(x_test)):\n",
    "\n",
    "        if np.isnan(x_test[i]):\n",
    "\n",
    "            probs[i] = np.nan\n",
    "\n",
    "        else:\n",
    "\n",
    "            pred = getProbabilityForClass(x_test[i], y_model, 0)\n",
    "\n",
    "            probs[i] = np.mean(pred < percentileMatrix[:, r])\n",
    "\n",
    "    return probs"
   ]
  },
  {
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitLogisticRegression(x_train, y_train, x_test, class_value):\n",
    "    '''\n",
    "    Fit logistic regression model with given training instances and return \n",
    "    probabilities for test instances to obtain a given class label.\n",
    "    \n",
    "    Arguments:\n",
    "    ----------\n",
    "    \n",
    "    x_train -- x values of training instances\n",
    "    y_train -- y values of training instances\n",
    "    x_test -- x values of test instances\n",
    "    class_value -- class label for which the probabilities are counted for.\n",
    "    \n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Trained LogisticRegression model\n",
    "    (2) Probabilities for given test inputs for given class.\n",
    "    '''\n",
    "\n",
    "    # Instantiate the model (using the default parameters)\n",
    "    logreg = LogisticRegression(solver='lbfgs')\n",
    "\n",
    "    # Check shape and fit the model.\n",
    "    if x_train.ndim == 1:\n",
    "        logreg = logreg.fit(x_train.values.reshape(-1, 1), y_train)\n",
    "    else:\n",
    "        logreg = logreg.fit(x_train, y_train)\n",
    "\n",
    "    label_probs_logreg = getProbabilityForClass(x_test, logreg, class_value)\n",
    "    \n",
    "    return logreg, label_probs_logreg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With unobservables in the data\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": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 [2] 0 1 2 3 4 [3] 0 1 2 3 4 [4] 0 1 2 3 4 [5] 0 1 2 3 4 [6] 0 1 2 3 4 [7] 0 1 2 3 4 [8] 0 1 2 3 4 "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.005      0.00196    0.01253451 0.00392556 0.0037947 ]\n",
      " [0.020544   0.008712   0.02705131 0.01643575 0.01346139]\n",
      " [0.046904   0.018432   0.04896482 0.04382398 0.02875426]\n",
      " [0.081032   0.03104    0.08585004 0.08461993 0.05115088]\n",
      " [0.126584   0.04808    0.13369051 0.13937302 0.08179428]\n",
      " [0.181336   0.067416   0.17873205 0.16580761 0.12189836]\n",
      " [0.2462     0.090424   0.24897104 0.25789903 0.17408225]\n",
      " [0.32052    0.114464   0.33116351 0.29375169 0.23064471]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.08094900000000001\n",
      "0.005505709619057343\n",
      "0.00982942433322089\n",
      "0.04031739816805024\n"
     ]
    }
   ],
   "source": [
    "failure_rates = np.zeros((8, 5))\n",
    "failure_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 5\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "\n",
    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
    "\n",
    "    f_rate_true = np.zeros(nIter)\n",
    "    f_rate_label = np.zeros(nIter)\n",
    "    f_rate_human = np.zeros(nIter)\n",
    "    f_rate_cont = np.zeros(nIter)\n",
    "    f_rate_caus = np.zeros(nIter)\n",
    "\n",
    "    for i in range(nIter):\n",
    "\n",
    "        print(i, end=\" \")\n",
    "\n",
    "        # Create data\n",
    "        train_labeled, train, test_labeled, test, df = dataWithUnobservables()\n",
    "\n",
    "        # Fit model and calculate predictions\n",
    "        logreg, predictions = fitLogisticRegression(\n",
    "            train_labeled.dropna().X,\n",
    "            train_labeled.dropna().result_Y, test.X, 0)\n",
    "\n",
    "        # Attach the predictions to data\n",
    "        test = test.assign(B_prob_0_logreg=predictions)\n",
    "\n",
    "        logreg, predictions_labeled = fitLogisticRegression(\n",
    "            train_labeled.dropna().X,\n",
    "            train_labeled.dropna().result_Y, test_labeled.X, 0)\n",
    "\n",
    "        test_labeled = test_labeled.assign(B_prob_0_logreg=predictions_labeled)\n",
    "\n",
    "        # True evaluation\n",
    "        #\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 those who were given a\n",
    "        # positive decision, i.e. those whose probability of negative outcome was\n",
    "        # low enough.\n",
    "        f_rate_true[i] = np.sum(\n",
    "            test.result_Y[0:to_release] == 0) / test.shape[0]\n",
    "\n",
    "        # Labeled outcomes only\n",
    "        #\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",
    "        f_rate_label[i] = np.sum(\n",
    "            test_labeled.result_Y[0:to_release] == 0) / test_labeled.shape[0]\n",
    "\n",
    "        # Human evaluation\n",
    "        #\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[\n",
    "            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",
    "        f_rate_human[i] = np.sum(\n",
    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",
    "\n",
    "        # Contraction, logistic regression\n",
    "        #\n",
    "        f_rate_cont[i] = contraction(test_labeled, 'judgeID_J', 'decision_T',\n",
    "                                     'result_Y', 'B_prob_0_logreg',\n",
    "                                     'acceptanceRate_R', r / 10)\n",
    "\n",
    "        # Causal model - empirical performance\n",
    "\n",
    "        released = bailIndicator(r * 10, logreg, train.X, test.X)\n",
    "\n",
    "        #released = cdf(test.X, logreg, 0) < r / 10\n",
    "\n",
    "        f_rate_caus[i] = np.mean(test.B_prob_0_logreg * released)\n",
    "\n",
    "        #percentiles = estimatePercentiles(train_labeled.X, logreg, N_sample=train_labeled.shape[0])\n",
    "\n",
    "        #def releaseProbability(x):\n",
    "        #    return calcReleaseProbabilities(r*10, train_labeled.X, x, logreg, percentileMatrix=percentiles)\n",
    "\n",
    "        #def integraali(x):\n",
    "        #    p_y0 = logreg.predict_proba(x.reshape(-1, 1))[:, 0]\n",
    "\n",
    "        #    p_t1 = releaseProbability(x)\n",
    "\n",
    "        #    p_x = scs.norm.pdf(x)\n",
    "\n",
    "        #    return p_y0 * p_t1 * p_x\n",
    "\n",
    "        #f_rate_caus[i] = si.quad(lambda x: integraali(np.ones((1, 1))*x), -10, 10)[0]\n",
    "\n",
    "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
    "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
    "    failure_rates[r - 1, 2] = np.mean(f_rate_human)\n",
    "    failure_rates[r - 1, 3] = np.mean(f_rate_cont)\n",
    "    failure_rates[r - 1, 4] = np.mean(f_rate_caus)\n",
    "\n",
    "    failure_sems[r - 1, 0] = scs.sem(f_rate_true)\n",
    "    failure_sems[r - 1, 1] = scs.sem(f_rate_label)\n",
    "    failure_sems[r - 1, 2] = scs.sem(f_rate_human)\n",
    "    failure_sems[r - 1, 3] = scs.sem(f_rate_cont)\n",
    "    failure_sems[r - 1, 4] = scs.sem(f_rate_caus)\n",
    "\n",
    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
    "\n",
    "plt.figure(figsize=(14, 8))\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 0],\n",
    "             label='True Evaluation',\n",
    "             c='green',\n",
    "             yerr=failure_sems[:, 0])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 1],\n",
    "             label='Labeled outcomes',\n",
    "             c='magenta',\n",
    "             yerr=failure_sems[:, 1])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 2],\n",
    "             label='Human evaluation',\n",
    "             c='red',\n",
    "             yerr=failure_sems[:, 2])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 3],\n",
    "             label='Contraction, log.',\n",
    "             c='blue',\n",
    "             yerr=failure_sems[:, 3])\n",
    "plt.errorbar(x_ax,\n",
    "             failure_rates[:, 4],\n",
    "             label='Causal model, ep',\n",
    "             c='black',\n",
    "             yerr=failure_sems[:, 4])\n",
    "\n",
    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
    "plt.xlabel('Acceptance rate')\n",
    "plt.ylabel('Failure rate')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "print(failure_rates)\n",
    "print(\"\\nMean absolute errors:\")\n",
    "for i in range(1, failure_rates.shape[1]):\n",
    "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Without unobservables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 5 6 7 8 9 [2] 0 1 2 3 4 5 6 7 8 9 [3] 0 1 2 3 4 5 6 7 8 9 [4] 0 1 2 3 4 5 6 7 8 9 [5] 0 1 2 3 4 5 6 7 8 9 [6] 0 1 2 3 4 5 6 7 8 9 [7] 0 1 2 3 4 5 6 7 8 9 [8] 0 1 2 3 4 5 6 7 8 9 "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.015536   0.005928   0.02170985 0.0180516  0.01562169]\n",
      " [0.041884   0.015828   0.04221962 0.04324741 0.04137089]\n",
      " [0.07538    0.027316   0.07771219 0.07215072 0.07554357]\n",
      " [0.115012   0.03972    0.1144968  0.11311276 0.11630691]\n",
      " [0.1618     0.050548   0.1643016  0.16000004 0.1618261 ]\n",
      " [0.215536   0.06848    0.21508377 0.22301954 0.21570745]\n",
      " [0.275708   0.082732   0.27766473 0.27981737 0.27674548]\n",
      " [0.341168   0.090472   0.33822295 0.34377554 0.34136872]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.107625\n",
      "0.0021515584224333704\n",
      "0.003125990647070036\n",
      "0.00043662683370912915\n"
     ]
    }
   ],
   "source": [
    "f_rates = np.zeros((8, 5))\n",
    "f_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 10\n",
    "\n",
    "for r in np.arange(1, 9):\n",
    "\n",
    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
    "\n",
    "    s_f_rate_true = np.zeros(nIter)\n",
    "    s_f_rate_labeled = np.zeros(nIter)\n",
    "    s_f_rate_human = np.zeros(nIter)\n",
    "    s_f_rate_cont = np.zeros(nIter)\n",
    "    s_f_rate_caus = np.zeros(nIter)\n",
    "\n",
    "    for i in range(nIter):\n",
    "\n",
    "        print(i, end=\" \")\n",
    "\n",
    "        s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables()\n",
    "\n",
    "        s_logreg, predictions = fitLogisticRegression(\n",
    "            s_train_labeled.dropna().X,\n",
    "            s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
    "        s_test = s_test.assign(B_prob_0_logreg=predictions)\n",
    "\n",
    "        s_logreg, predictions_labeled = fitLogisticRegression(\n",
    "            s_train_labeled.dropna().X,\n",
    "            s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
    "        s_test_labeled = s_test_labeled.assign(\n",
    "            B_prob_0_logreg=predictions_labeled)\n",
    "\n",
    "        #### True evaluation\n",
    "        # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
    "        s_sorted = s_test.sort_values(by='probabilities_Y',\n",
    "                                      inplace=False,\n",
    "                                      ascending=True)\n",
    "\n",
    "        to_release = int(round(s_sorted.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",
    "        s_f_rate_true[i] = np.sum(\n",
    "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
    "\n",
    "        #### Labeled outcomes\n",
    "        # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
    "        s_sorted = s_test_labeled.sort_values(by='B_prob_0_logreg',\n",
    "                                              inplace=False,\n",
    "                                              ascending=True)\n",
    "\n",
    "        to_release = int(round(s_test_labeled.dropna().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",
    "        s_f_rate_labeled[i] = np.sum(\n",
    "            s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
    "\n",
    "        #### Human error rate\n",
    "        # Get judges with correct leniency as list\n",
    "        correct_leniency_list = s_test_labeled.judgeID_J[\n",
    "            s_test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
    "\n",
    "        # Released are the people they judged and released, T = 1\n",
    "        released = s_test_labeled[\n",
    "            s_test_labeled.judgeID_J.isin(correct_leniency_list)\n",
    "            & (s_test_labeled.decision_T == 1)]\n",
    "\n",
    "        # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
    "        s_f_rate_human[i] = np.sum(\n",
    "            released.result_Y == 0) / correct_leniency_list.shape[0]\n",
    "\n",
    "        #### Contraction\n",
    "        s_f_rate_cont[i] = contraction(s_test_labeled, 'judgeID_J',\n",
    "                                       'decision_T', 'result_Y',\n",
    "                                       'B_prob_0_logreg', 'acceptanceRate_R',\n",
    "                                       r / 10)\n",
    "        #### Causal model\n",
    "\n",
    "        released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",