Analysis_07MAY2019_old.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=\"#Data-without-unobservables\" data-toc-modified-id=\"Data-without-unobservables-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Data without unobservables</a></span></li><li><span><a href=\"#Synthetic-data-with-unobservables\" data-toc-modified-id=\"Synthetic-data-with-unobservables-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Synthetic data with 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=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>With unobservables in the data</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': (10, 6)})\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",
    "### 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\\{-X\\}})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
    "\n",
    "    # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
    "    # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\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",
    "    # 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": [
    "### 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": [
    "## 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": 14,
   "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": 22,
   "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(-15, 15, 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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitPredictiveModel(x_train, y_train, x_test, class_value, model_type=None):\n",
    "    '''\n",
    "    Fit a predictive model (default logistic regression) with given training \n",
    "    instances and return probabilities for test instances to obtain a given \n",
    "    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",
    "    model_type -- type of model to be fitted.\n",
    "    \n",
    "    Returns:\n",
    "    --------\n",
    "    (1) Trained predictive model\n",
    "    (2) Probabilities for given test inputs for given class.\n",
    "    '''\n",
    "\n",
    "    if model_type is None or model_type in [\"logistic_regression\", \"lr\"]:\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\n",
    "    \n",
    "    elif model_type in [\"random_forest\", \"rf\"]:\n",
    "        # Instantiate the model \n",
    "        forest = RandomForestClassifier(n_estimators=100, max_depth=3)\n",
    "\n",
    "        # Check shape and fit the model.\n",
    "        if x_train.ndim == 1:\n",
    "            forest = forest.fit(x_train.values.reshape(-1, 1), y_train)\n",
    "        else:\n",
    "            forest = forest.fit(x_train, y_train)\n",
    "\n",
    "        label_probs_forest = getProbabilityForClass(x_test, forest, class_value)\n",
    "\n",
    "        return forest, label_probs_forest\n",
    "    \n",
    "    elif model_type == \"fully_random\":\n",
    "        \n",
    "        label_probs = np.ones_like(x_test) / 2\n",
    "        \n",
    "        model_object = lambda x: 0.5\n",
    "        \n",
    "        return model_object, label_probs\n",
    "    else:\n",
    "        raise ValueError(\"Invalid model_type!\", model_type) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Without unobservables in the data\n",
    "\n",
    "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 5 6 7 [2] 0 1 2 3 4 5 6 7 [3] 0 1 2 3 4 5 6 7 [4] 0 1 2 3 4 5 6 7 [5] 0 1 2 3 4 5 6 7 [6] 0 1 2 3 4 5 6 7 [7] 0 1 2 3 4 5 6 7 [8] 0 1 2 3 4 5 6 7 "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.015455   0.005975   0.02128927 0.01824005 0.01504878]\n",
      " [0.041615   0.01541    0.04449708 0.04952796 0.04207918]\n",
      " [0.075705   0.02737    0.07408005 0.07451198 0.07586959]\n",
      " [0.114615   0.03845    0.11454849 0.1089716  0.11612646]\n",
      " [0.161915   0.055585   0.16090506 0.170813   0.16261346]\n",
      " [0.214345   0.067335   0.21142173 0.21125308 0.21550736]\n",
      " [0.275515   0.079615   0.27699615 0.271816   0.27544641]\n",
      " [0.340255   0.091685   0.34350266 0.33641304 0.33994187]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.10724937500000001\n",
      "0.00238372897518402\n",
      "0.004633164376337144\n",
      "0.0005986237333166415\n"
     ]
    }
   ],
   "source": [
    "f_rates = np.zeros((8, 5))\n",
    "f_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 8\n",
    "\n",
    "#npr.seed(0)\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 = fitPredictiveModel(\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_model=predictions)\n",
    "\n",
    "        s_logreg, predictions_labeled = fitPredictiveModel(\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_model=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='B_prob_0_model',\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_model',\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_model', 'acceptanceRate_R',\n",
    "                                       r / 10)\n",
    "        #### Causal model\n",
    "\n",
    "        #released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",
    "\n",
    "        released = cdf(s_test.X, s_logreg, 0) < r / 10\n",
    "\n",
    "        s_f_rate_caus[i] = np.mean(s_test.B_prob_0_model * released)\n",
    "\n",
    "        ########################\n",
    "        #percentiles = estimatePercentiles(s_train_labeled.X, s_logreg)\n",
    "\n",
    "        #def releaseProbability(x):\n",
    "        #    return calcReleaseProbabilities(r * 10,\n",
    "        #                                     s_train_labeled.X,\n",
    "        #                                     x,\n",
    "        #                                     s_logreg,\n",
    "        #                                     percentileMatrix=percentiles)\n",
    "\n",
    "        #def integrand(x):\n",
    "        #    p_y0 = s_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",
    "        #s_f_rate_caus[i] = si.quad(lambda x: integrand(np.ones((1, 1)) * x),\n",
    "        #                           -10, 10)[0]\n",
    "\n",
    "    f_rates[r - 1, 0] = np.mean(s_f_rate_true)\n",
    "    f_rates[r - 1, 1] = np.mean(s_f_rate_labeled)\n",
    "    f_rates[r - 1, 2] = np.mean(s_f_rate_human)\n",
    "    f_rates[r - 1, 3] = np.mean(s_f_rate_cont)\n",
    "    f_rates[r - 1, 4] = np.mean(s_f_rate_caus)\n",
    "\n",
    "    f_sems[r - 1, 0] = scs.sem(s_f_rate_true)\n",
    "    f_sems[r - 1, 1] = scs.sem(s_f_rate_labeled)\n",
    "    f_sems[r - 1, 2] = scs.sem(s_f_rate_human)\n",
    "    f_sems[r - 1, 3] = scs.sem(s_f_rate_cont)\n",
    "    f_sems[r - 1, 4] = scs.sem(s_f_rate_caus)\n",
    "\n",
    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
    "\n",
    "plt.errorbar(x_ax,\n",
    "             f_rates[:, 0],\n",
    "             label='True Evaluation',\n",
    "             c='green',\n",
    "             yerr=f_sems[:, 0])\n",
    "plt.errorbar(x_ax,\n",
    "             f_rates[:, 1],\n",
    "             label='Labeled outcomes',\n",
    "             c='magenta',\n",
    "             yerr=f_sems[:, 1])\n",
    "plt.errorbar(x_ax,\n",
    "             f_rates[:, 2],\n",
    "             label='Human evaluation',\n",
    "             c='red',\n",
    "             yerr=f_sems[:, 2])\n",
    "plt.errorbar(x_ax,\n",
    "             f_rates[:, 3],\n",
    "             label='Contraction, log.',\n",
    "             c='blue',\n",
    "             yerr=f_sems[:, 3])\n",
    "plt.errorbar(x_ax,\n",
    "             f_rates[:, 4],\n",
    "             label='Causal model, ep',\n",
    "             c='black',\n",
    "             yerr=f_sems[:, 4])\n",
    "\n",
    "plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
    "plt.xlabel('Acceptance rate')\n",
    "plt.ylabel('Failure rate')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "print(f_rates)\n",
    "print(\"\\nMean absolute errors:\")\n",
    "for i in range(1, f_rates.shape[1]):\n",
    "    print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
   ]
  },
  {
   "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": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 0 1 2 3 4 5 6 7 [2] 0 1 2 3 4 5 6 7 [3] 0 1 2 3 4 5 6 7 [4] 0 1 2 3 4 5 6 7 [5] 0 1 2 3 4 5 6 7 [6] 0 1 2 3 4 5 6 7 [7] 0 1 2 3 4 5 6 7 [8] 0 1 2 3 4 5 6 7 "
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00543    0.002235   0.01173347 0.00462072 0.00371409]\n",
      " [0.02073    0.00829    0.02260202 0.02491425 0.01286922]\n",
      " [0.046295   0.01716    0.05069571 0.04167522 0.02791597]\n",
      " [0.081615   0.030765   0.0848586  0.0723175  0.05149991]\n",
      " [0.12755    0.048135   0.12889808 0.12994054 0.08148183]\n",
      " [0.18077    0.06486    0.18545546 0.16258617 0.11982914]\n",
      " [0.24507    0.083195   0.25131055 0.23464198 0.16797487]\n",
      " [0.319775   0.11032    0.32569484 0.30929089 0.23272432]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.082784375\n",
      "0.0042517158692163435\n",
      "0.007549662902501246\n",
      "0.0411532050110707\n"
     ]
    }
   ],
   "source": [
    "failure_rates = np.zeros((8, 5))\n",
    "failure_sems = np.zeros((8, 5))\n",
    "\n",
    "nIter = 8\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 = fitPredictiveModel(\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_model=predictions)\n",
    "\n",
    "        logreg, predictions_labeled = fitPredictiveModel(\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_model=predictions_labeled)\n",
    "\n",
    "#         # Regress T on X\n",
    "#         lr_t, __ = fitPredictiveModel(train_labeled.X,\n",
    "#                                          train_labeled.decision_T, np.ones(1),\n",
    "#                                          1)\n",
    "#         # Calculate the residuals from previous regression\n",
    "#         residuals_T = train_labeled.decision_T - \\\n",
    "#             lr_t.predict(train_labeled.X.values.reshape(-1, 1))\n",
    "#         train_labeled = train_labeled.assign(residuals_T=residuals_T)\n",
    "\n",
    "#         # Convert residuals from -1, 0 and 1 values to one-hot-encoded.\n",
    "#         # this way there will be separate betas for each type of residual.\n",
    "#         enc = OneHotEncoder(categories='auto')\n",
    "#         resid_tf = train_labeled.residuals_T.values.reshape(-1, 1)\n",
    "#         tmp = enc.fit_transform(resid_tf).toarray()\n",
    "#         train_labeled = train_labeled.assign(residuals_1=tmp[:, 0],\n",