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": 19,
   "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': 20})\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": 20,
   "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": 21,
   "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": [
    "## 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": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "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.005528   0.002432   0.01319786 0.00887781 0.00390224]\n",
      " [0.020472   0.008472   0.02678623 0.01623446 0.01343422]\n",
      " [0.045624   0.017488   0.04746294 0.04551294 0.02767315]\n",
      " [0.081824   0.032264   0.08350139 0.06776128 0.0517766 ]\n",
      " [0.126928   0.04788    0.12481927 0.13252636 0.08095011]\n",
      " [0.18104    0.067056   0.18657521 0.17784578 0.12028829]\n",
      " [0.246552   0.086248   0.25726453 0.23153227 0.17033782]\n",
      " [0.319384   0.110344   0.31863215 0.32273764 0.23110259]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.081896\n",
      "0.004576093219252864\n",
      "0.006115883691462761\n",
      "0.040985871600081346\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": 26,
   "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 [[0.015576   0.00602    0.01871832 0.0155083  0.01510369]\n",
      " [0.041464   0.014844   0.04123791 0.04585791 0.04120556]\n",
      " [0.074556   0.026952   0.07557791 0.07502445 0.07488912]\n",
      " [0.116628   0.039788   0.1204208  0.11675328 0.11489007]\n",
      " [0.163516   0.05352    0.16388655 0.15724707 0.16348454]\n",
      " [0.215324   0.067472   0.21566634 0.20960815 0.21556262]\n",
      " [0.275304   0.0796     0.27068253 0.26999024 0.27246517]\n",
      " [0.34266    0.097512   0.34633772 0.33894081 0.34189467]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.10741499999999998\n",
      "0.002149400883940101\n",
      "0.0032591338380606296\n",
      "0.0008345057598423591\n"
     ]
    },
    {
     "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": [
    "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",
    "\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_logreg * released)\n",
    "\n",
    "        ########################\n",
    "        #percentiles = estimatePercentiles(s_train_labeled.X, s_logreg)\n",
    "\n",
    "        #def releaseProbability(x):\n",