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': 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": 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": 3,
   "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": 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.005272   0.0022     0.01185422 0.00477498 0.00373072]\n",
      " [0.020416   0.008216   0.02264994 0.01984985 0.01282219]\n",
      " [0.0464     0.018488   0.05118037 0.04056628 0.02904038]\n",
      " [0.081488   0.03168    0.08739625 0.06748708 0.05058666]\n",
      " [0.12568    0.044408   0.13005694 0.11619114 0.07896761]\n",
      " [0.181688   0.067952   0.18660673 0.15385259 0.12205216]\n",
      " [0.24628    0.082264   0.2452843  0.23542718 0.16662356]\n",
      " [0.321144   0.10956    0.32001659 0.338259   0.2292687 ]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.08295\n",
      "0.0038654443097572524\n",
      "0.010773738532573306\n",
      "0.04190950174490609\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\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": 8,
   "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.015368   0.005808   0.01995777 0.01516406 0.01594067]\n",
      " [0.041416   0.015836   0.04321981 0.04789159 0.04243067]\n",
      " [0.076044   0.0261     0.07418454 0.07789905 0.07412071]\n",
      " [0.116112   0.039852   0.11635393 0.11883984 0.11509014]\n",
      " [0.162124   0.052308   0.16481971 0.16338339 0.16305947]\n",
      " [0.216192   0.06732    0.21387284 0.23024922 0.21453262]\n",
      " [0.274452   0.080512   0.27114682 0.27166327 0.27669359]\n",
      " [0.3408     0.100856   0.34501975 0.35435532 0.34294369]]\n",
      "\n",
      "Mean absolute errors:\n",
      "0.1067395\n",
      "0.002629345839201819\n",
      "0.005365384751435717\n",
      "0.001439077136508043\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",